opencode-synced 0.6.0 → 0.7.1

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,12 +28,7 @@ Enable the plugin in your global OpenCode config (OpenCode will install it on ne
 }
 ```
 
-OpenCode does not auto-update plugins. To update, remove the cached plugin and restart OpenCode:
-
-```bash
-rm -rf ~/.cache/opencode/node_modules/opencode-synced
-opencode
-```
+opencode does not auto-update plugins. To update, modify the version number in your config file.
 
 ## Configure
 
@@ -55,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
 
@@ -106,7 +101,7 @@ 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
 {
@@ -163,8 +158,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
 
@@ -183,7 +178,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
 
@@ -270,7 +265,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
@@ -284,7 +279,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-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'])
@@ -200,8 +200,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

@@ -1,6 +1,6 @@
 import { promises as fs } from 'node:fs';
 import path from 'node:path';
-import { deepMerge, hasOwn, parseJsonc, pathExists, stripOverrides, writeJsonFile, } from './config.js';
+import { chmodIfExists, deepMerge, hasOwn, parseJsonc, pathExists, stripOverrides, writeJsonFile, } from './config.js';
 import { extractMcpSecrets, hasOverrides, mergeOverrides, stripOverrideKeys, } from './mcp-secrets.js';
 import { normalizePath } from './paths.js';
 export async function syncRepoToLocal(plan, overrides) {
@@ -117,7 +117,7 @@ async function copyFileWithMode(sourcePath, destinationPath) {
     const stat = await fs.stat(sourcePath);
     await fs.mkdir(path.dirname(destinationPath), { recursive: true });
     await fs.copyFile(sourcePath, destinationPath);
-    await fs.chmod(destinationPath, stat.mode & 0o777);
+    await chmodIfExists(destinationPath, stat.mode & 0o777);
 }
 async function copyDirRecursive(sourcePath, destinationPath) {
     const stat = await fs.stat(sourcePath);
@@ -134,7 +134,7 @@ async function copyDirRecursive(sourcePath, destinationPath) {
             await copyFileWithMode(entrySource, entryDest);
         }
     }
-    await fs.chmod(destinationPath, stat.mode & 0o777);
+    await chmodIfExists(destinationPath, stat.mode & 0o777);
 }
 async function removePath(targetPath) {
     await fs.rm(targetPath, { recursive: true, force: true });
@@ -161,7 +161,7 @@ async function applyExtraSecrets(plan, fromRepo) {
         if (fromRepo) {
             await copyFileWithMode(repoPath, localPath);
             if (entry.mode !== undefined) {
-                await fs.chmod(localPath, entry.mode);
+                await chmodIfExists(localPath, entry.mode);
             }
         }
     }

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

@@ -20,6 +20,7 @@ export interface SyncState {
     lastRemoteUpdate?: string;
 }
 export declare function pathExists(filePath: string): Promise<boolean>;
+export declare function chmodIfExists(filePath: string, mode: number): Promise<void>;
 export declare function normalizeSyncConfig(config: SyncConfig): SyncConfig;
 export declare function canCommitMcpSecrets(config: SyncConfig): boolean;
 export declare function loadSyncConfig(locations: SyncLocations): Promise<SyncConfig | null>;

package/dist/sync/config.js

@@ -9,6 +9,17 @@ export async function pathExists(filePath) {
         return false;
     }
 }
+export async function chmodIfExists(filePath, mode) {
+    try {
+        await fs.chmod(filePath, mode);
+    }
+    catch (error) {
+        const maybeErrno = error;
+        if (maybeErrno.code === 'ENOENT')
+            return;
+        throw error;
+    }
+}
 export function normalizeSyncConfig(config) {
     const includeSecrets = Boolean(config.includeSecrets);
     return {
@@ -177,7 +188,7 @@ export async function writeJsonFile(filePath, data, options = { jsonc: false })
     const content = options.jsonc ? `// Generated by opencode-synced\n${json}\n` : `${json}\n`;
     await fs.writeFile(filePath, content, 'utf8');
     if (options.mode !== undefined) {
-        await fs.chmod(filePath, options.mode);
+        await chmodIfExists(filePath, options.mode);
     }
 }
 export function isPlainObject(value) {

package/dist/sync/lock.d.ts

@@ -0,0 +1,17 @@
+export interface SyncLockInfo {
+    pid: number;
+    startedAt: string;
+    hostname: string;
+}
+export type SyncLockResult = {
+    acquired: true;
+    info: SyncLockInfo;
+    release: () => Promise<void>;
+} | {
+    acquired: false;
+    info: SyncLockInfo | null;
+};
+export declare function tryAcquireSyncLock(lockPath: string): Promise<SyncLockResult>;
+export declare function withSyncLock<T>(lockPath: string, options: {
+    onBusy: (info: SyncLockInfo | null) => T | Promise<T>;
+}, fn: () => Promise<T>): Promise<T>;

package/dist/sync/lock.js

@@ -0,0 +1,91 @@
+import { mkdir, open, readFile, rm } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+function isProcessAlive(pid) {
+    if (!Number.isFinite(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        const maybeErrno = error;
+        if (maybeErrno.code === 'ESRCH')
+            return false;
+        return true;
+    }
+}
+async function readLockInfo(lockPath) {
+    try {
+        const content = await readFile(lockPath, 'utf8');
+        const parsed = JSON.parse(content);
+        if (typeof parsed.pid !== 'number')
+            return null;
+        if (typeof parsed.startedAt !== 'string')
+            return null;
+        if (typeof parsed.hostname !== 'string')
+            return null;
+        return {
+            pid: parsed.pid,
+            startedAt: parsed.startedAt,
+            hostname: parsed.hostname,
+        };
+    }
+    catch (error) {
+        const maybeErrno = error;
+        if (maybeErrno.code === 'ENOENT')
+            return null;
+        return null;
+    }
+}
+export async function tryAcquireSyncLock(lockPath) {
+    const parentDir = path.dirname(lockPath);
+    await mkdir(parentDir, { recursive: true });
+    const ourInfo = {
+        pid: process.pid,
+        startedAt: new Date().toISOString(),
+        hostname: os.hostname(),
+    };
+    let attempt = 0;
+    while (true) {
+        try {
+            const handle = await open(lockPath, 'wx');
+            await handle.writeFile(`${JSON.stringify(ourInfo, null, 2)}\n`, 'utf8');
+            return {
+                acquired: true,
+                info: ourInfo,
+                release: async () => {
+                    await handle.close().catch(() => {
+                        // ignore close failures
+                    });
+                    await rm(lockPath, { force: true });
+                },
+            };
+        }
+        catch (error) {
+            const maybeErrno = error;
+            if (maybeErrno.code !== 'EEXIST')
+                throw error;
+            const existing = await readLockInfo(lockPath);
+            const shouldBreakLock = existing === null || !isProcessAlive(existing.pid);
+            if (attempt === 0 && shouldBreakLock) {
+                await rm(lockPath, { force: true });
+                attempt += 1;
+                continue;
+            }
+            return { acquired: false, info: existing };
+        }
+    }
+}
+export async function withSyncLock(lockPath, options, fn) {
+    const result = await tryAcquireSyncLock(lockPath);
+    if (!result.acquired) {
+        return await options.onBusy(result.info);
+    }
+    try {
+        return await fn();
+    }
+    finally {
+        await result.release();
+    }
+}

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.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');

package/dist/sync/service.js

@@ -1,15 +1,38 @@
+import path from 'node:path';
 import { syncLocalToRepo, syncRepoToLocal } from './apply.js';
 import { generateCommitMessage } from './commit.js';
 import { canCommitMcpSecrets, loadOverrides, loadState, loadSyncConfig, normalizeSyncConfig, writeState, writeSyncConfig, } from './config.js';
 import { SyncCommandError, SyncConfigMissingError } from './errors.js';
+import { withSyncLock } from './lock.js';
 import { buildSyncPlan, resolveRepoRoot, resolveSyncLocations } from './paths.js';
 import { commitAll, ensureRepoCloned, ensureRepoPrivate, fetchAndFastForward, findSyncRepo, getAuthenticatedUser, getRepoStatus, hasLocalChanges, isRepoCloned, pushBranch, repoExists, resolveRepoBranch, resolveRepoIdentifier, } from './repo.js';
 import { createLogger, extractTextFromResponse, resolveSmallModel, showToast, unwrapData, } from './utils.js';
 export function createSyncService(ctx) {
     const locations = resolveSyncLocations();
     const log = createLogger(ctx.client);
+    const lockPath = path.join(path.dirname(locations.statePath), 'sync.lock');
+    const formatLockInfo = (info) => {
+        if (!info)
+            return 'Another sync is already in progress.';
+        return `Another sync is already in progress (pid ${info.pid} on ${info.hostname}, started ${info.startedAt}).`;
+    };
+    const runExclusive = (fn) => withSyncLock(lockPath, {
+        onBusy: (info) => {
+            throw new SyncCommandError(formatLockInfo(info));
+        },
+    }, fn);
+    const skipIfBusy = (fn) => withSyncLock(lockPath, {
+        onBusy: (info) => {
+            log.debug('Sync already running, skipping', {
+                pid: info?.pid,
+                hostname: info?.hostname,
+                startedAt: info?.startedAt,
+            });
+            return;
+        },
+    }, fn);
     return {
-        startupSync: async () => {
+        startupSync: () => skipIfBusy(async () => {
             let config = null;
             try {
                 config = await loadSyncConfig(locations);
@@ -31,7 +54,7 @@ export function createSyncService(ctx) {
                 log.error('Startup sync failed', { error: formatError(error) });
                 await showToast(ctx.client, formatError(error), 'error');
             }
-        },
+        }),
         status: async () => {
             const config = await loadSyncConfig(locations);
             if (!config) {
@@ -87,7 +110,7 @@ export function createSyncService(ctx) {
             ];
             return statusLines.join('\n');
         },
-        init: async (options) => {
+        init: (options) => runExclusive(async () => {
             const config = await buildConfigFromInit(ctx.$, options);
             const repoIdentifier = resolveRepoIdentifier(config);
             const isPrivate = options.private ?? true;
@@ -123,8 +146,8 @@ export function createSyncService(ctx) {
                 `Local repo: ${repoRoot}`,
             ];
             return lines.join('\n');
-        },
-        link: async (options) => {
+        }),
+        link: (options) => runExclusive(async () => {
             const found = await findSyncRepo(ctx.$, options.repo);
             if (!found) {
                 const searchedFor = options.repo
@@ -164,19 +187,19 @@ 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: async () => {
+        }),
+        pull: () => runExclusive(async () => {
             const config = await getConfigOrThrow(locations);
             const repoRoot = resolveRepoRoot(config, locations);
             await ensureRepoCloned(ctx.$, config, repoRoot);
@@ -197,10 +220,10 @@ 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.';
-        },
-        push: async () => {
+            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);
             const repoRoot = resolveRepoRoot(config, locations);
             await ensureRepoCloned(ctx.$, config, repoRoot);
@@ -227,8 +250,8 @@ export function createSyncService(ctx) {
                 lastPush: new Date().toISOString(),
             });
             return `Pushed changes: ${message}`;
-        },
-        enableSecrets: async (options) => {
+        }),
+        enableSecrets: (options) => runExclusive(async () => {
             const config = await getConfigOrThrow(locations);
             config.includeSecrets = true;
             if (options?.extraSecretPaths) {
@@ -240,8 +263,8 @@ export function createSyncService(ctx) {
             await ensureRepoPrivate(ctx.$, config);
             await writeSyncConfig(locations, config);
             return 'Secrets sync enabled for this repo.';
-        },
-        resolve: async () => {
+        }),
+        resolve: () => runExclusive(async () => {
             const config = await getConfigOrThrow(locations);
             const repoRoot = resolveRepoRoot(config, locations);
             await ensureRepoCloned(ctx.$, config, repoRoot);
@@ -267,7 +290,7 @@ export function createSyncService(ctx) {
                 }
             }
             return `Unable to automatically resolve. Please manually resolve in: ${repoRoot}`;
-        },
+        }),
     };
 }
 async function runStartup(ctx, locations, config, log) {
@@ -293,7 +316,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);

package/package.json

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