Merge pull request #29 from iHildy/feat/extra-config-sync

feat: Add support syncing extra config paths

Author: iHildy

README.md

@@ -77,6 +77,7 @@ Create `~/.config/opencode/opencode-synced.jsonc`:
   "includeSessions": false,
   "includePromptStash": false,
   "extraSecretPaths": [],
+  "extraConfigPaths": [],
 }
 ```
 
@@ -87,14 +88,15 @@ Create `~/.config/opencode/opencode-synced.jsonc`:
 - `~/.config/opencode/opencode.json` and `opencode.jsonc`
 - `~/.config/opencode/AGENTS.md`
 - `~/.config/opencode/agent/`, `command/`, `mode/`, `tool/`, `themes/`, `plugin/`
+- Any extra paths in `extraConfigPaths` (allowlist, files or folders)
 
 ### Secrets (private repos only)
 
 Enable secrets with `/sync-enable-secrets` or set `"includeSecrets": true`:
 
 - `~/.local/share/opencode/auth.json`
 - `~/.local/share/opencode/mcp-auth.json`
-- Any extra paths in `extraSecretPaths` (allowlist)
+- Any extra paths in `extraSecretPaths` (allowlist, files or folders)
 
 MCP API keys stored inside `opencode.json(c)` are **not** committed by default. To allow them
 in a private repo, set `"includeMcpSecrets": true` (requires `includeSecrets`).

src/command/sync-init.md

@@ -10,3 +10,4 @@ If the user wants an org-owned repo, pass owner="org-name".
 If the user wants a public repo, pass private=false.
 Include includeSecrets if the user explicitly opts in.
 Include includeMcpSecrets only if they want MCP secrets committed to a private repo.
+If the user supplies extra config paths, pass extraConfigPaths.

src/index.ts

@@ -140,6 +140,7 @@ export const opencodeConfigSync: Plugin = async (ctx) => {
       create: tool.schema.boolean().optional().describe('Create repo if missing'),
       private: tool.schema.boolean().optional().describe('Create repo as private'),
       extraSecretPaths: tool.schema.array(tool.schema.string()).optional(),
+      extraConfigPaths: tool.schema.array(tool.schema.string()).optional(),
       localRepoPath: tool.schema.string().optional().describe('Override local repo path'),
     },
     async execute(args) {
@@ -161,6 +162,7 @@ export const opencodeConfigSync: Plugin = async (ctx) => {
             create: args.create,
             private: args.private,
             extraSecretPaths: args.extraSecretPaths,
+            extraConfigPaths: args.extraConfigPaths,
             localRepoPath: args.localRepoPath,
           });
         }

src/sync/apply.ts

@@ -16,17 +16,27 @@ import {
   mergeOverrides,
   stripOverrideKeys,
 } from './mcp-secrets.js';
-import type { SyncItem, SyncPlan } from './paths.js';
+import type { ExtraPathPlan, SyncItem, SyncPlan } from './paths.js';
 import { normalizePath } from './paths.js';
 
-interface ExtraSecretManifestEntry {
+type ExtraPathType = 'file' | 'dir';
+
+interface ExtraPathManifestItem {
+  relativePath: string;
+  type: ExtraPathType;
+  mode?: number;
+}
+
+interface ExtraPathManifestEntry {
   sourcePath: string;
   repoPath: string;
+  type?: ExtraPathType;
   mode?: number;
+  items?: ExtraPathManifestItem[];
 }
 
-interface ExtraSecretManifest {
-  entries: ExtraSecretManifestEntry[];
+interface ExtraPathManifest {
+  entries: ExtraPathManifestEntry[];
 }
 
 export async function syncRepoToLocal(
@@ -37,7 +47,8 @@ export async function syncRepoToLocal(
     await copyItem(item.repoPath, item.localPath, item.type);
   }
 
-  await applyExtraSecrets(plan, true);
+  await applyExtraPaths(plan, plan.extraConfigs);
+  await applyExtraPaths(plan, plan.extraSecrets);
 
   if (overrides && Object.keys(overrides).length > 0) {
     await applyOverridesToLocalConfig(plan, overrides);
@@ -90,7 +101,8 @@ export async function syncLocalToRepo(
     await copyItem(item.localPath, item.repoPath, item.type, true);
   }
 
-  await writeExtraSecretsManifest(plan);
+  await writeExtraPathManifest(plan, plan.extraConfigs);
+  await writeExtraPathManifest(plan, plan.extraSecrets);
 }
 
 async function copyItem(
@@ -212,14 +224,14 @@ async function removePath(targetPath: string): Promise<void> {
   await fs.rm(targetPath, { recursive: true, force: true });
 }
 
-async function applyExtraSecrets(plan: SyncPlan, fromRepo: boolean): Promise<void> {
-  const allowlist = plan.extraSecrets.allowlist;
+async function applyExtraPaths(plan: SyncPlan, extra: ExtraPathPlan): Promise<void> {
+  const allowlist = extra.allowlist;
   if (allowlist.length === 0) return;
 
-  if (!(await pathExists(plan.extraSecrets.manifestPath))) return;
+  if (!(await pathExists(extra.manifestPath))) return;
 
-  const manifestContent = await fs.readFile(plan.extraSecrets.manifestPath, 'utf8');
-  const manifest = parseJsonc<ExtraSecretManifest>(manifestContent);
+  const manifestContent = await fs.readFile(extra.manifestPath, 'utf8');
+  const manifest = parseJsonc<ExtraPathManifest>(manifestContent);
 
   for (const entry of manifest.entries) {
     const normalized = normalizePath(entry.sourcePath, plan.homeDir, plan.platform);
@@ -230,47 +242,136 @@ async function applyExtraSecrets(plan: SyncPlan, fromRepo: boolean): Promise<voi
       ? entry.repoPath
       : path.join(plan.repoRoot, entry.repoPath);
     const localPath = entry.sourcePath;
+    const entryType: ExtraPathType = entry.type ?? 'file';
 
     if (!(await pathExists(repoPath))) continue;
 
-    if (fromRepo) {
-      await copyFileWithMode(repoPath, localPath);
-      if (entry.mode !== undefined) {
-        await chmodIfExists(localPath, entry.mode);
-      }
-    }
+    await copyItem(repoPath, localPath, entryType);
+    await applyExtraPathModes(localPath, entry);
   }
 }
 
-async function writeExtraSecretsManifest(plan: SyncPlan): Promise<void> {
-  const allowlist = plan.extraSecrets.allowlist;
-  const extraDir = path.join(path.dirname(plan.extraSecrets.manifestPath), 'extra');
+async function writeExtraPathManifest(plan: SyncPlan, extra: ExtraPathPlan): Promise<void> {
+  const allowlist = extra.allowlist;
+  const extraDir = path.join(path.dirname(extra.manifestPath), 'extra');
   if (allowlist.length === 0) {
-    await removePath(plan.extraSecrets.manifestPath);
+    await removePath(extra.manifestPath);
     await removePath(extraDir);
     return;
   }
 
   await removePath(extraDir);
 
-  const entries: ExtraSecretManifestEntry[] = [];
+  const entries: ExtraPathManifestEntry[] = [];
 
-  for (const entry of plan.extraSecrets.entries) {
+  for (const entry of extra.entries) {
     const sourcePath = entry.sourcePath;
     if (!(await pathExists(sourcePath))) {
       continue;
     }
     const stat = await fs.stat(sourcePath);
-    await copyFileWithMode(sourcePath, entry.repoPath);
-    entries.push({
-      sourcePath,
-      repoPath: path.relative(plan.repoRoot, entry.repoPath),
-      mode: stat.mode & 0o777,
-    });
+    if (stat.isDirectory()) {
+      await copyDirRecursive(sourcePath, entry.repoPath);
+      const items = await collectExtraPathItems(sourcePath, sourcePath);
+      entries.push({
+        sourcePath,
+        repoPath: path.relative(plan.repoRoot, entry.repoPath),
+        type: 'dir',
+        mode: stat.mode & 0o777,
+        items,
+      });
+      continue;
+    }
+    if (stat.isFile()) {
+      await copyFileWithMode(sourcePath, entry.repoPath);
+      entries.push({
+        sourcePath,
+        repoPath: path.relative(plan.repoRoot, entry.repoPath),
+        type: 'file',
+        mode: stat.mode & 0o777,
+      });
+    }
+  }
+
+  await fs.mkdir(path.dirname(extra.manifestPath), { recursive: true });
+  await writeJsonFile(extra.manifestPath, { entries }, { jsonc: false });
+}
+
+async function collectExtraPathItems(
+  sourcePath: string,
+  basePath: string
+): Promise<ExtraPathManifestItem[]> {
+  const items: ExtraPathManifestItem[] = [];
+  const entries = await fs.readdir(sourcePath, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const entrySource = path.join(sourcePath, entry.name);
+    const relativePath = path.relative(basePath, entrySource);
+
+    if (entry.isDirectory()) {
+      const stat = await fs.stat(entrySource);
+      items.push({
+        relativePath,
+        type: 'dir',
+        mode: stat.mode & 0o777,
+      });
+      const nested = await collectExtraPathItems(entrySource, basePath);
+      items.push(...nested);
+      continue;
+    }
+
+    if (entry.isFile()) {
+      const stat = await fs.stat(entrySource);
+      items.push({
+        relativePath,
+        type: 'file',
+        mode: stat.mode & 0o777,
+      });
+    }
+  }
+
+  return items;
+}
+
+async function applyExtraPathModes(
+  targetPath: string,
+  entry: ExtraPathManifestEntry
+): Promise<void> {
+  if (entry.mode !== undefined) {
+    await chmodIfExists(targetPath, entry.mode);
+  }
+
+  if (entry.type !== 'dir') {
+    return;
+  }
+
+  if (!entry.items || entry.items.length === 0) {
+    return;
+  }
+
+  for (const item of entry.items) {
+    if (item.mode === undefined) continue;
+    const itemPath = resolveExtraPathItem(targetPath, item.relativePath);
+    if (!itemPath) continue;
+    await chmodIfExists(itemPath, item.mode);
+  }
+}
+
+function resolveExtraPathItem(basePath: string, relativePath: string): string | null {
+  if (!relativePath) return null;
+  if (path.isAbsolute(relativePath)) return null;
+
+  const resolvedBase = path.resolve(basePath);
+  const resolvedPath = path.resolve(basePath, relativePath);
+  const relative = path.relative(resolvedBase, resolvedPath);
+  if (relative === '..' || relative.startsWith(`..${path.sep}`)) {
+    return null;
+  }
+  if (path.isAbsolute(relative)) {
+    return null;
   }
 
-  await fs.mkdir(path.dirname(plan.extraSecrets.manifestPath), { recursive: true });
-  await writeJsonFile(plan.extraSecrets.manifestPath, { entries }, { jsonc: false });
+  return resolvedPath;
 }
 
 function isDeepEqual(left: unknown, right: unknown): boolean {

src/sync/config.test.ts

@@ -94,12 +94,16 @@ describe('parseJsonc', () => {
       "extraSecretPaths": [
         "foo",
       ],
+      "extraConfigPaths": [
+        "bar",
+      ],
     }`;
 
     expect(parseJsonc(input)).toEqual({
       repo: { owner: 'me', name: 'opencode-config' },
       includeSecrets: false,
       extraSecretPaths: ['foo'],
+      extraConfigPaths: ['bar'],
     });
   });
 });

src/sync/config.ts

@@ -18,6 +18,7 @@ export interface SyncConfig {
   includeSessions?: boolean;
   includePromptStash?: boolean;
   extraSecretPaths?: string[];
+  extraConfigPaths?: string[];
 }
 
 export interface SyncState {
@@ -53,6 +54,7 @@ export function normalizeSyncConfig(config: SyncConfig): SyncConfig {
     includeSessions: Boolean(config.includeSessions),
     includePromptStash: Boolean(config.includePromptStash),
     extraSecretPaths: Array.isArray(config.extraSecretPaths) ? config.extraSecretPaths : [],
+    extraConfigPaths: Array.isArray(config.extraConfigPaths) ? config.extraConfigPaths : [],
     localRepoPath: config.localRepoPath,
     repo: config.repo,
   };

src/sync/paths.test.ts

@@ -47,13 +47,15 @@ describe('buildSyncPlan', () => {
       repo: { owner: 'acme', name: 'config' },
       includeSecrets: false,
       extraSecretPaths: ['/home/test/.ssh/id_rsa'],
+      extraConfigPaths: ['/home/test/.config/opencode/custom.json'],
     };
 
     const plan = buildSyncPlan(config, locations, '/repo', 'linux');
     const secretItems = plan.items.filter((item) => item.isSecret);
 
     expect(secretItems.length).toBe(0);
     expect(plan.extraSecrets.allowlist.length).toBe(0);
+    expect(plan.extraConfigs.allowlist.length).toBe(1);
   });
 
   it('includes secrets when includeSecrets is true', () => {
@@ -63,12 +65,14 @@ describe('buildSyncPlan', () => {
       repo: { owner: 'acme', name: 'config' },
       includeSecrets: true,
       extraSecretPaths: ['/home/test/.ssh/id_rsa'],
+      extraConfigPaths: ['/home/test/.config/opencode/custom.json'],
     };
 
     const plan = buildSyncPlan(config, locations, '/repo', 'linux');
     const secretItems = plan.items.filter((item) => item.isSecret);
 
     expect(secretItems.length).toBe(2);
     expect(plan.extraSecrets.allowlist.length).toBe(1);
+    expect(plan.extraConfigs.allowlist.length).toBe(1);
   });
 });