opencode-synced 0.7.0 → 0.8.0

package/README.md

@@ -1,10 +1,10 @@
 # opencode-synced
 
-Sync global OpenCode configuration across machines via a GitHub repo, with optional secrets support for private repos.
+Sync global opencode configuration across machines via a GitHub repo, with optional secrets support for private repos.
 
 ## Features
 
-- Syncs global OpenCode config (`~/.config/opencode`) and related directories
+- Syncs global opencode config (`~/.config/opencode`) and related directories
 - Optional secrets sync when the repo is private
 - Optional session sync to share conversation history across machines
 - Optional prompt stash sync to share stashed prompts and history across machines
@@ -19,7 +19,7 @@ Sync global OpenCode configuration across machines via a GitHub repo, with optio
 
 ## Setup
 
-Enable the plugin in your global OpenCode config (OpenCode will install it on next run):
+Enable the plugin in your global opencode config (opencode will install it on next run):
 
 ```jsonc
 {
@@ -28,7 +28,7 @@ Enable the plugin in your global OpenCode config (OpenCode will install it on ne
 }
 ```
 
-OpenCode does not auto-update plugins. To update, modify the version number in your config file.
+opencode does not auto-update plugins. To update, modify the version number in your config file.
 
 ## Configure
 
@@ -50,7 +50,7 @@ Run `/sync-link` to connect to your existing sync repo:
 
 If auto-detection fails, specify the repo name: `/sync-link my-opencode-config`
 
-After linking, restart OpenCode to apply the synced settings.
+After linking, restart opencode to apply the synced settings.
 
 ### Custom repo name or org
 
@@ -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,14 +96,14 @@ 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`).
 
 ### Sessions (private repos only)
 
-Sync your OpenCode sessions (conversation history from `/sessions`) across machines by setting `"includeSessions": true`. This requires `includeSecrets` to also be enabled since sessions may contain sensitive data.
+Sync your opencode sessions (conversation history from `/sessions`) across machines by setting `"includeSessions": true`. This requires `includeSecrets` to also be enabled since sessions may contain sensitive data.
 
 ```jsonc
 {
@@ -158,8 +160,8 @@ If you want MCP secrets committed (private repos only), set `"includeMcpSecrets"
 Env var naming rules:
 
 - If the header name already looks like an env var (e.g. `CONTEXT7_API_KEY`), it is used directly.
-- Otherwise: `OPENCODE_MCP_<SERVER>_<HEADER>` (uppercase, non-alphanumerics become `_`).
-- OAuth client secrets use `OPENCODE_MCP_<SERVER>_OAUTH_CLIENT_SECRET`.
+- Otherwise: `opencode_mcp_<SERVER>_<HEADER>` (non-alphanumerics become `_`).
+- OAuth client secrets use `opencode_mcp_<SERVER>_OAUTH_CLIENT_SECRET`.
 
 ## Usage
 
@@ -178,7 +180,7 @@ Env var naming rules:
 
 ### Trigger a sync
 
-Restart OpenCode to run the startup sync flow (pull remote, apply if changed, push local changes if needed).
+Restart opencode to run the startup sync flow (pull remote, apply if changed, push local changes if needed).
 
 ### Check status
 
@@ -265,7 +267,7 @@ bun -e '
 ### Local testing (production-like)
 
 To test the same artifact that would be published, install from a packed tarball
-into OpenCode's cache:
+into opencode's cache:
 
 ```bash
 mise run local-pack-test
@@ -279,7 +281,7 @@ Then set `~/.config/opencode/opencode.json` to use:
 }
 ```
 
-Restart OpenCode to pick up the cached install.
+Restart opencode to pick up the cached install.
 
 
 ## Prefer a CLI version?

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/command/sync-link.md

@@ -5,11 +5,11 @@ description: Link this computer to an existing sync repo
 Use the opencode_sync tool with command "link".
 This command is for linking a second (or additional) computer to an existing sync repo that was created on another machine.
 
-IMPORTANT: This will OVERWRITE the local OpenCode configuration with the contents from the synced repo. The only thing preserved is the local overrides file (opencode-synced.overrides.jsonc).
+IMPORTANT: This will OVERWRITE the local opencode configuration with the contents from the synced repo. The only thing preserved is the local overrides file (opencode-synced.overrides.jsonc).
 
 If the user provides a repo name argument, pass it as name="repo-name".
 If no repo name is provided, the tool will automatically search for common sync repo names.
 
 After linking:
-- Remind the user to restart OpenCode to apply the synced config
+- Remind the user to restart opencode to apply the synced config
 - If they want to enable secrets sync, they should run /sync-enable-secrets

package/dist/command/sync-pull.md

@@ -1,6 +1,6 @@
 ---
-description: Pull and apply synced OpenCode config
+description: Pull and apply synced opencode config
 ---
 
 Use the opencode_sync tool with command "pull".
-If updates are applied, remind the user to restart OpenCode.
+If updates are applied, remind the user to restart opencode.

package/dist/command/sync-push.md

@@ -1,5 +1,5 @@
 ---
-description: Push local OpenCode config to the sync repo
+description: Push local opencode config to the sync repo
 ---
 
 Use the opencode_sync tool with command "push".

package/dist/index.d.ts

@@ -1,4 +1,4 @@
 import type { Plugin } from '@opencode-ai/plugin';
-export declare const OpencodeConfigSync: Plugin;
-export declare const OpencodeSynced: Plugin;
-export default OpencodeConfigSync;
+export declare const opencodeConfigSync: Plugin;
+export declare const opencodeSynced: Plugin;
+export default opencodeConfigSync;

package/dist/index.js

@@ -85,11 +85,11 @@ async function loadCommands() {
     }
     return commands;
 }
-export const OpencodeConfigSync = async (ctx) => {
+export const opencodeConfigSync = async (ctx) => {
     const commands = await loadCommands();
     const service = createSyncService(ctx);
     const syncTool = tool({
-        description: 'Manage OpenCode config sync with a GitHub repo',
+        description: 'Manage opencode config sync with a GitHub repo',
         args: {
             command: tool.schema
                 .enum(['status', 'init', 'link', 'pull', 'push', 'enable-secrets', 'resolve'])
@@ -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,
                     });
                 }
@@ -200,8 +202,8 @@ export const OpencodeConfigSync = async (ctx) => {
         },
     };
 };
-export const OpencodeSynced = OpencodeConfigSync;
-export default OpencodeConfigSync;
+export const opencodeSynced = opencodeConfigSync;
+export default opencodeConfigSync;
 function formatError(error) {
     if (error instanceof Error)
         return error.message;

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/commit.js

@@ -1,6 +1,6 @@
 import { extractTextFromResponse, resolveSmallModel, unwrapData } from './utils.js';
 export async function generateCommitMessage(ctx, repoDir, fallbackDate = new Date()) {
-    const fallback = `Sync OpenCode config (${formatDate(fallbackDate)})`;
+    const fallback = `Sync opencode config (${formatDate(fallbackDate)})`;
     const diffSummary = await getDiffSummary(ctx.$, repoDir);
     if (!diffSummary)
         return fallback;
@@ -9,7 +9,7 @@ export async function generateCommitMessage(ctx, repoDir, fallbackDate = new Dat
         return fallback;
     const prompt = [
         'Generate a concise single-line git commit message (max 72 chars).',
-        'Focus on OpenCode config sync changes.',
+        'Focus on opencode config sync changes.',
         'Return only the message, no quotes.',
         '',
         'Diff summary:',

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/mcp-secrets.js

@@ -46,7 +46,7 @@ function buildHeaderEnvVar(serverName, headerName) {
 function buildEnvVar(serverName, key) {
     const serverToken = toEnvToken(serverName, 'SERVER');
     const keyToken = toEnvToken(key, 'VALUE');
-    return `OPENCODE_MCP_${serverToken}_${keyToken}`;
+    return `opencode_mcp_${serverToken}_${keyToken}`;
 }
 function toEnvToken(input, fallback) {
     const cleaned = String(input)

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

@@ -39,7 +39,7 @@ export function resolveXdgPaths(env = process.env, platform = process.platform)
 }
 export function resolveSyncLocations(env = process.env, platform = process.platform) {
     const xdg = resolveXdgPaths(env, platform);
-    const customConfigDir = env.OPENCODE_CONFIG_DIR;
+    const customConfigDir = env.opencode_config_dir;
     const configRoot = customConfigDir
         ? path.resolve(expandHome(customConfigDir, xdg.homeDir))
         : path.join(xdg.configDir, 'opencode');
@@ -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);
@@ -187,16 +188,16 @@ export function createSyncService(ctx) {
             const lines = [
                 `Linked to existing sync repo: ${found.owner}/${found.name}`,
                 '',
-                'Your local OpenCode config has been OVERWRITTEN with the synced config.',
+                'Your local opencode config has been OVERWRITTEN with the synced config.',
                 'Your local overrides file was preserved and applied on top.',
                 '',
-                'Restart OpenCode to apply the new settings.',
+                'Restart opencode to apply the new settings.',
                 '',
                 found.isPrivate
                     ? 'To enable secrets sync, run: /sync-enable-secrets'
                     : 'Note: Repo is public. Secrets sync is disabled.',
             ];
-            await showToast(ctx.client, 'Config synced. Restart OpenCode to apply.', 'info');
+            await showToast(ctx.client, 'Config synced. Restart opencode to apply.', 'info');
             return lines.join('\n');
         }),
         pull: () => runExclusive(async () => {
@@ -220,8 +221,8 @@ export function createSyncService(ctx) {
                 lastPull: new Date().toISOString(),
                 lastRemoteUpdate: new Date().toISOString(),
             });
-            await showToast(ctx.client, 'Config updated. Restart OpenCode to apply.', 'info');
-            return 'Remote config applied. Restart OpenCode to use new settings.';
+            await showToast(ctx.client, 'Config updated. Restart opencode to apply.', 'info');
+            return 'Remote config applied. Restart opencode to use new settings.';
         }),
         push: () => runExclusive(async () => {
             const config = await getConfigOrThrow(locations);
@@ -316,7 +317,7 @@ async function runStartup(ctx, locations, config, log) {
             lastPull: new Date().toISOString(),
             lastRemoteUpdate: new Date().toISOString(),
         });
-        await showToast(ctx.client, 'Config updated. Restart OpenCode to apply.', 'info');
+        await showToast(ctx.client, 'Config updated. Restart opencode to apply.', 'info');
         return;
     }
     const overrides = await loadOverrides(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,7 +1,7 @@
 {
   "name": "opencode-synced",
-  "version": "0.7.0",
-  "description": "Sync global OpenCode config across machines via GitHub.",
+  "version": "0.8.0",
+  "description": "Sync global opencode config across machines via GitHub.",
   "author": {
     "name": "Ian Hildebrand"
   },