opencode-synced 0.5.1 → 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 {
@@ -106,34 +117,14 @@ export function stripOverrides(localConfig, overrides, baseConfig) {
     return result;
 }
 export function parseJsonc(content) {
-    const stripped = stripJsonComments(content);
-    return JSON.parse(stripped);
-}
-export async function writeJsonFile(filePath, data, options = { jsonc: false }) {
-    const json = JSON.stringify(data, null, 2);
-    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);
-    }
-}
-export function isPlainObject(value) {
-    if (!value || typeof value !== 'object')
-        return false;
-    return Object.getPrototypeOf(value) === Object.prototype;
-}
-export function hasOwn(target, key) {
-    return Object.hasOwn(target, key);
-}
-function stripJsonComments(input) {
     let output = '';
     let inString = false;
     let inSingleLine = false;
     let inMultiLine = false;
     let escapeNext = false;
-    for (let i = 0; i < input.length; i += 1) {
-        const current = input[i];
-        const next = input[i + 1];
+    for (let i = 0; i < content.length; i += 1) {
+        const current = content[i];
+        const next = content[i + 1];
         if (inSingleLine) {
             if (current === '\n') {
                 inSingleLine = false;
@@ -163,7 +154,7 @@ function stripJsonComments(input) {
             }
             continue;
         }
-        if (current === '"' && !inString) {
+        if (current === '"') {
             inString = true;
             output += current;
             continue;
@@ -178,7 +169,33 @@ function stripJsonComments(input) {
             i += 1;
             continue;
         }
+        if (current === ',') {
+            let nextIndex = i + 1;
+            while (nextIndex < content.length && /\s/.test(content[nextIndex])) {
+                nextIndex += 1;
+            }
+            const nextChar = content[nextIndex];
+            if (nextChar === '}' || nextChar === ']') {
+                continue;
+            }
+        }
         output += current;
     }
-    return output;
+    return JSON.parse(output);
+}
+export async function writeJsonFile(filePath, data, options = { jsonc: false }) {
+    const json = JSON.stringify(data, null, 2);
+    const content = options.jsonc ? `// Generated by opencode-synced\n${json}\n` : `${json}\n`;
+    await fs.writeFile(filePath, content, 'utf8');
+    if (options.mode !== undefined) {
+        await chmodIfExists(filePath, options.mode);
+    }
+}
+export function isPlainObject(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    return Object.getPrototypeOf(value) === Object.prototype;
+}
+export function hasOwn(target, key) {
+    return Object.hasOwn(target, key);
 }

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,16 +1,48 @@
+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 () => {
-            const config = await loadSyncConfig(locations);
+        startupSync: () => skipIfBusy(async () => {
+            let config = null;
+            try {
+                config = await loadSyncConfig(locations);
+            }
+            catch (error) {
+                const message = `Failed to load opencode-synced config: ${formatError(error)}`;
+                log.error(message, { path: locations.syncConfigPath });
+                await showToast(ctx.client, `Failed to load opencode-synced config. Check ${locations.syncConfigPath} for JSON errors.`, 'error');
+                return;
+            }
             if (!config) {
                 await showToast(ctx.client, 'Configure opencode-synced with /sync-init or link to an existing repo with /sync-link', 'info');
                 return;
@@ -22,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) {
@@ -78,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;
@@ -114,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
@@ -166,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);
@@ -190,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);
@@ -218,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) {
@@ -231,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);
@@ -258,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/dist/sync/utils.js

@@ -23,9 +23,14 @@ function log(client, level, message, extra) {
     });
 }
 export async function showToast(client, message, variant) {
-    await client.tui.showToast({
-        body: { title: 'opencode-synced plugin', message, variant },
-    });
+    try {
+        await client.tui.showToast({
+            body: { title: 'opencode-synced plugin', message, variant },
+        });
+    }
+    catch {
+        // Ignore toast failures (e.g. headless mode or early startup).
+    }
 }
 export function unwrapData(response) {
     if (!response || typeof response !== 'object')

package/package.json

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