opencode-synced 0.6.0 → 0.7.0

package/README.md

@@ -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
 

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/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/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
@@ -175,8 +198,8 @@ export function createSyncService(ctx) {
             ];
             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);
@@ -199,8 +222,8 @@ export function createSyncService(ctx) {
             });
             await showToast(ctx.client, 'Config updated. Restart OpenCode to apply.', 'info');
             return 'Remote config applied. Restart OpenCode to use new settings.';
-        },
-        push: async () => {
+        }),
+        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) {

package/package.json

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