opencode-synced 0.7.1 → 0.8.0

package/README.md

@@ -77,6 +77,7 @@ Create `~/.config/opencode/opencode-synced.jsonc`:
   "includeSessions": false,
   "includePromptStash": false,
   "extraSecretPaths": [],
+  "extraConfigPaths": [],
 }
 ```
 
@@ -87,6 +88,7 @@ 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)
 
@@ -94,7 +96,7 @@ 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`).

package/dist/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.

package/dist/index.js

@@ -115,6 +115,7 @@ export const opencodeConfigSync = 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) {
@@ -136,6 +137,7 @@ export const opencodeConfigSync = async (ctx) => {
                         create: args.create,
                         private: args.private,
                         extraSecretPaths: args.extraSecretPaths,
+                        extraConfigPaths: args.extraConfigPaths,
                         localRepoPath: args.localRepoPath,
                     });
                 }

package/dist/sync/apply.js

@@ -7,7 +7,8 @@ export async function syncRepoToLocal(plan, overrides) {
     for (const item of plan.items) {
         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);
     }
@@ -49,7 +50,8 @@ export async function syncLocalToRepo(plan, overrides, options = {}) {
         }
         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(sourcePath, destinationPath, type, removeWhenMissing = false) {
     if (!(await pathExists(sourcePath))) {
@@ -139,13 +141,13 @@ async function copyDirRecursive(sourcePath, destinationPath) {
 async function removePath(targetPath) {
     await fs.rm(targetPath, { recursive: true, force: true });
 }
-async function applyExtraSecrets(plan, fromRepo) {
-    const allowlist = plan.extraSecrets.allowlist;
+async function applyExtraPaths(plan, extra) {
+    const allowlist = extra.allowlist;
     if (allowlist.length === 0)
         return;
-    if (!(await pathExists(plan.extraSecrets.manifestPath)))
+    if (!(await pathExists(extra.manifestPath)))
         return;
-    const manifestContent = await fs.readFile(plan.extraSecrets.manifestPath, 'utf8');
+    const manifestContent = await fs.readFile(extra.manifestPath, 'utf8');
     const manifest = parseJsonc(manifestContent);
     for (const entry of manifest.entries) {
         const normalized = normalizePath(entry.sourcePath, plan.homeDir, plan.platform);
@@ -156,41 +158,116 @@ async function applyExtraSecrets(plan, fromRepo) {
             ? entry.repoPath
             : path.join(plan.repoRoot, entry.repoPath);
         const localPath = entry.sourcePath;
+        const entryType = 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) {
-    const allowlist = plan.extraSecrets.allowlist;
-    const extraDir = path.join(path.dirname(plan.extraSecrets.manifestPath), 'extra');
+async function writeExtraPathManifest(plan, extra) {
+    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 = [];
-    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, basePath) {
+    const items = [];
+    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, entry) {
+    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, relativePath) {
+    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, right) {
     if (left === right)

package/dist/sync/config.d.ts

@@ -13,6 +13,7 @@ export interface SyncConfig {
     includeSessions?: boolean;
     includePromptStash?: boolean;
     extraSecretPaths?: string[];
+    extraConfigPaths?: string[];
 }
 export interface SyncState {
     lastPull?: string;

package/dist/sync/config.js

@@ -28,6 +28,7 @@ export function normalizeSyncConfig(config) {
         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,
     };

package/dist/sync/paths.d.ts

@@ -21,7 +21,7 @@ export interface SyncItem {
     isSecret: boolean;
     isConfigFile: boolean;
 }
-export interface ExtraSecretPlan {
+export interface ExtraPathPlan {
     allowlist: string[];
     manifestPath: string;
     entries: Array<{
@@ -31,7 +31,8 @@ export interface ExtraSecretPlan {
 }
 export interface SyncPlan {
     items: SyncItem[];
-    extraSecrets: ExtraSecretPlan;
+    extraSecrets: ExtraPathPlan;
+    extraConfigs: ExtraPathPlan;
     repoRoot: string;
     homeDir: string;
     platform: NodeJS.Platform;
@@ -42,6 +43,7 @@ export declare function resolveSyncLocations(env?: NodeJS.ProcessEnv, platform?:
 export declare function expandHome(inputPath: string, homeDir: string): string;
 export declare function normalizePath(inputPath: string, homeDir: string, platform?: NodeJS.Platform): string;
 export declare function isSamePath(left: string, right: string, homeDir: string, platform?: NodeJS.Platform): boolean;
-export declare function encodeSecretPath(inputPath: string): string;
+export declare function encodeExtraPath(inputPath: string): string;
+export declare const encodeSecretPath: typeof encodeExtraPath;
 export declare function resolveRepoRoot(config: SyncConfig | null, locations: SyncLocations): string;
 export declare function buildSyncPlan(config: SyncConfig, locations: SyncLocations, repoRoot: string, platform?: NodeJS.Platform): SyncPlan;

package/dist/sync/paths.js

@@ -75,13 +75,14 @@ export function normalizePath(inputPath, homeDir, platform = process.platform) {
 export function isSamePath(left, right, homeDir, platform = process.platform) {
     return normalizePath(left, homeDir, platform) === normalizePath(right, homeDir, platform);
 }
-export function encodeSecretPath(inputPath) {
+export function encodeExtraPath(inputPath) {
     const normalized = inputPath.replace(/\\/g, '/');
     const safeBase = normalized.replace(/[^a-zA-Z0-9._-]+/g, '_').replace(/^_+/, '');
     const hash = crypto.createHash('sha1').update(normalized).digest('hex').slice(0, 8);
-    const base = safeBase ? safeBase.slice(-80) : 'secret';
+    const base = safeBase ? safeBase.slice(-80) : 'path';
     return `${base}-${hash}`;
 }
+export const encodeSecretPath = encodeExtraPath;
 export function resolveRepoRoot(config, locations) {
     if (config?.localRepoPath) {
         return expandHome(config.localRepoPath, locations.xdg.homeDir);
@@ -96,6 +97,8 @@ export function buildSyncPlan(config, locations, repoRoot, platform = process.pl
     const repoSecretsRoot = path.join(repoRoot, 'secrets');
     const repoExtraDir = path.join(repoSecretsRoot, 'extra');
     const manifestPath = path.join(repoSecretsRoot, 'extra-manifest.json');
+    const repoConfigExtraDir = path.join(repoConfigRoot, 'extra');
+    const configManifestPath = path.join(repoConfigRoot, 'extra-manifest.json');
     const items = [];
     const addFile = (name, isSecret, isConfigFile) => {
         items.push({
@@ -157,22 +160,26 @@ export function buildSyncPlan(config, locations, repoRoot, platform = process.pl
             }
         }
     }
-    const allowlist = config.includeSecrets
-        ? (config.extraSecretPaths ?? []).map((entry) => normalizePath(entry, locations.xdg.homeDir, platform))
-        : [];
-    const entries = allowlist.map((sourcePath) => ({
-        sourcePath,
-        repoPath: path.join(repoExtraDir, encodeSecretPath(sourcePath)),
-    }));
+    const extraSecrets = buildExtraPathPlan(config.includeSecrets ? config.extraSecretPaths : [], locations, repoExtraDir, manifestPath, platform);
+    const extraConfigs = buildExtraPathPlan(config.extraConfigPaths, locations, repoConfigExtraDir, configManifestPath, platform);
     return {
         items,
-        extraSecrets: {
-            allowlist,
-            manifestPath,
-            entries,
-        },
+        extraSecrets,
+        extraConfigs,
         repoRoot,
         homeDir: locations.xdg.homeDir,
         platform,
     };
 }
+function buildExtraPathPlan(inputPaths, locations, repoExtraDir, manifestPath, platform) {
+    const allowlist = (inputPaths ?? []).map((entry) => normalizePath(entry, locations.xdg.homeDir, platform));
+    const entries = allowlist.map((sourcePath) => ({
+        sourcePath,
+        repoPath: path.join(repoExtraDir, encodeExtraPath(sourcePath)),
+    }));
+    return {
+        allowlist,
+        manifestPath,
+        entries,
+    };
+}

package/dist/sync/service.d.ts

@@ -13,6 +13,7 @@ interface InitOptions {
     create?: boolean;
     private?: boolean;
     extraSecretPaths?: string[];
+    extraConfigPaths?: string[];
     localRepoPath?: string;
 }
 interface LinkOptions {

package/dist/sync/service.js

@@ -171,6 +171,7 @@ export function createSyncService(ctx) {
                 includeSessions: false,
                 includePromptStash: false,
                 extraSecretPaths: [],
+                extraConfigPaths: [],
             });
             await writeSyncConfig(locations, config);
             const repoRoot = resolveRepoRoot(config, locations);
@@ -369,6 +370,7 @@ async function buildConfigFromInit($, options) {
         includeSessions: options.includeSessions ?? false,
         includePromptStash: options.includePromptStash ?? false,
         extraSecretPaths: options.extraSecretPaths ?? [],
+        extraConfigPaths: options.extraConfigPaths ?? [],
         localRepoPath: options.localRepoPath,
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-synced",
-  "version": "0.7.1",
+  "version": "0.8.0",
   "description": "Sync global opencode config across machines via GitHub.",
   "author": {
     "name": "Ian Hildebrand"