zedx 0.8.1 → 0.10.0

package/README.md

@@ -1,6 +1,10 @@
-# zedx
+<div align="center">
 
-Scaffold [Zed Editor](https://zed.dev/) extensions and sync your settings across machines.
+<img src="./assets/zedx-logo.png" width="300" alt="ZedX Logo" />
+
+CLI toolkit for Scaffolding [Zed Editor](https://zed.dev/) extensions and syncing settings across machines.
+
+</div>
 
 ![screenshot](./assets/screenshot1.png)
 
@@ -13,7 +17,9 @@ npm install -g zedx
 brew install tahayvr/tap/zedx
 ```
 
-### Usage
+## Usage
+
+### Scaffolding an extension
 
 ```bash
 # Create a new extension
@@ -22,26 +28,77 @@ zedx create
 # Add a theme or language to an existing extension
 zedx add theme "Midnight Blue"
 zedx add language rust
+```
+
+### Supported extension types:
+
+1. **Themes** - Color schemes for the editor
+2. **Languages** - Syntax highlighting, indentation, and optional LSP support
+
+You can choose to include theme, language, or both when creating an extension.
+
+### Validation
 
+```bash
 # Validate extension config and show what is missing or incomplete
 zedx check
+```
+
+### Sync
+
+Sync your Zed config across machines using a private GitHub repo as the source of truth.
+
+**1. Link a repo (one-time setup)**
+
+```bash
+zedx sync init
+```
+
+Prompts for a GitHub repo URL (SSH or HTTPS) and a branch name (defaults to `main`). The repo is saved to `~/.config/zedx/config.json`. No files are synced yet.
+
+> [!NOTE]
+> `settings.json` and `keymap.json` are tracked. Extension sync is handled via the `auto_install_extensions` field within `settings.json`, which Zed uses to automatically download and install extensions.
+
+**2. Run a sync**
 
-# Bump extension version
+```bash
+zedx sync            # Sync local ↔ remote, prompts when both sides changed
+zedx sync --local    # Always keep local on conflict (no prompt)
+zedx sync --remote   # Always use remote on conflict (no prompt)
+```
+
+**3. Check sync state**
+
+```bash
+zedx sync status
+```
+
+**4. Auto-sync with an OS daemon**
+
+```bash
+zedx sync install    # Install and enable the daemon
+zedx sync uninstall  # Disable and remove the daemon
+```
+
+Installs a file-watcher that triggers `zedx sync` automatically whenever config files are saved. Supported platforms:
+
+| Platform | Mechanism                                              | Logs                                     |
+| -------- | ------------------------------------------------------ | ---------------------------------------- |
+| macOS    | launchd (`~/Library/LaunchAgents/dev.zedx.sync.plist`) | `~/Library/Logs/zedx-sync.log`           |
+| Linux    | systemd user units (`~/.config/systemd/user/`)         | `journalctl --user -u zedx-sync.service` |
+
+The daemon enforces a 30-second throttle on macOS to avoid rapid re-triggers. When a conflict is detected in daemon mode (no TTY), local always wins and a warning is logged.
+
+### Versioning
+
+Bump the extension version:
+
+```bash
 zedx version patch   # 1.2.3 → 1.2.4
 zedx version minor   # 1.2.3 → 1.3.0
 zedx version major   # 1.2.3 → 2.0.0
-
-# Sync Zed settings and extensions via a GitHub repo
-zedx sync init       # Link a GitHub repo as the sync target (run once)
-zedx sync            # Sync local and remote config automatically
-zedx sync status     # Show sync state between local config and the remote repo
-zedx sync install    # Install an OS daemon to auto-sync when Zed config changes
-zedx sync uninstall  # Remove the OS daemon
 ```
 
-### Supported extension types:
+### License
 
-1. **Themes** - Color schemes for the editor
-2. **Languages** - Syntax highlighting, indentation, and optional LSP support
-
-You can choose to include theme, language, or both when creating an extension.
+License is Apache-2.0. See [LICENSE](./LICENSE) for details.

package/dist/daemon.js

@@ -157,7 +157,7 @@ export async function syncInstall() {
     if (platform !== 'darwin' && platform !== 'linux')
         unsupportedPlatform();
     const zedPaths = resolveZedPaths();
-    const watchPaths = [zedPaths.settings, zedPaths.extensions];
+    const watchPaths = [zedPaths.settings, zedPaths.keymap];
     const zedxBin = resolveZedxBinary();
     p.log.info(`Binary:  ${color.dim(zedxBin)}`);
     p.log.info(`Watching:`);

package/dist/index.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import { createRequire } from 'module';
 import path from 'path';
 import * as p from '@clack/prompts';
 import { Command } from 'commander';
@@ -11,7 +12,9 @@ import { generateExtension } from './generator.js';
 import { installDevExtension } from './install.js';
 import { promptUser, promptThemeDetails, promptLanguageDetails } from './prompts.js';
 import { addLsp } from './snippet.js';
-import { syncInit, runSync, syncStatus } from './sync.js';
+import { syncInit, runSync, syncStatus, syncSelect } from './sync.js';
+const require = createRequire(import.meta.url);
+const { version } = require('../package.json');
 function bumpVersion(version, type) {
     const [major, minor, patch] = version.split('.').map(Number);
     switch (type) {
@@ -65,6 +68,7 @@ function printWelcome() {
         ['zedx install', 'Install as a Zed dev extension'],
         ['zedx version <major|minor|patch>', 'Bump extension version'],
         ['zedx sync', 'Sync Zed settings via a git repo'],
+        ['zedx sync select', 'Choose which files to sync interactively'],
         ['zedx sync init', 'Link a git repo as the sync target'],
         ['zedx sync status', 'Show sync state between local and remote'],
         ['zedx sync install', 'Install the OS daemon for auto-sync'],
@@ -74,7 +78,7 @@ function printWelcome() {
     for (const [cmd, desc] of commands) {
         console.log(`  ${color.cyan(cmd.padEnd(38))}${color.dim(desc)}`);
     }
-    console.log(`\n  ${color.dim('Docs:')} ${color.underline(color.blue('https://zed.dev/docs/extensions'))}\n`);
+    console.log(`\n  ${color.dim('Zed Docs:')} ${color.underline(color.blue('https://zed.dev/docs/extensions'))}\n`);
 }
 async function runCreate() {
     const options = await promptUser();
@@ -99,7 +103,7 @@ async function runCreate() {
 }
 async function main() {
     const program = new Command();
-    program.name('zedx').description('The CLI toolkit for Zed Editor.').helpOption(false);
+    program.name('zedx').description('The CLI toolkit for Zed Editor.').version(`zedx v${version}`);
     program
         .command('create')
         .description('Scaffold a new Zed extension')
@@ -156,8 +160,19 @@ async function main() {
     const syncCmd = program
         .command('sync')
         .description('Sync Zed settings and extensions via a GitHub repo')
-        .action(async () => {
-        await runSync();
+        .option('--local', 'On conflict, always keep the local version')
+        .option('--remote', 'On conflict, always use the remote version')
+        .action(async (opts) => {
+        if (opts.local && opts.remote) {
+            p.log.error(color.red('--local and --remote are mutually exclusive.'));
+            process.exit(1);
+        }
+        const conflict = opts.local
+            ? 'local'
+            : opts.remote
+                ? 'remote'
+                : 'prompt';
+        await runSync({ conflict });
     });
     syncCmd
         .command('init')
@@ -171,6 +186,12 @@ async function main() {
         .action(async () => {
         await syncStatus();
     });
+    syncCmd
+        .command('select')
+        .description('Interactively choose which files to sync')
+        .action(async () => {
+        await syncSelect();
+    });
     syncCmd
         .command('install')
         .description('Install the OS daemon to auto-sync when Zed config changes')
@@ -183,10 +204,11 @@ async function main() {
         .action(async () => {
         await syncUninstall();
     });
-    if (process.argv.length <= 2) {
+    const argv = process.argv.filter(arg => arg !== '--');
+    if (argv.length <= 2) {
         printWelcome();
         return;
     }
-    program.parse(process.argv);
+    program.parse(argv);
 }
 main().catch(console.error);

package/dist/snippet.js

@@ -165,5 +165,5 @@ export async function addLsp(callerDir) {
     p.outro(`${color.green('✓')} LSP snippet added.\n\n` +
         `  ${color.dim('1.')} Edit ${color.cyan('src/lib.rs')} — implement ${color.white('language_server_command')}\n` +
         `  ${color.dim('2.')} Edit ${color.cyan('Cargo.toml')} — pin ${color.white('zed_extension_api')} to latest version\n` +
-        `  ${color.dim('3.')} ${color.dim('Docs:')} ${color.underline(color.blue('https://zed.dev/docs/extensions/languages#language-servers'))}`);
+        `  ${color.dim('3.')} ${color.dim('Zed Docs:')} ${color.underline(color.blue('https://zed.dev/docs/extensions/languages#language-servers'))}`);
 }

package/dist/sync.d.ts

@@ -1,5 +1,9 @@
 export declare function syncStatus(): Promise<void>;
 export declare function syncInit(): Promise<void>;
+export type ConflictStrategy = 'local' | 'remote' | 'prompt';
+export declare function syncSelect(): Promise<void>;
 export declare function runSync(opts?: {
     silent?: boolean;
+    conflict?: ConflictStrategy;
+    selectedFiles?: string[];
 }): Promise<void>;

package/dist/sync.js

@@ -37,76 +37,66 @@ async function withTempDir(fn) {
         await fs.remove(tmp);
     }
 }
-// Prepare settings.json for pushing to the repo by stripping auto_install_extensions.
-// That field is derived from extensions/index.json on pull, so storing it in the
-// remote would create stale/conflicting data across machines.
-async function prepareSettingsForPush(localSettingsPath, repoSettingsPath) {
-    const raw = await fs.readFile(localSettingsPath, 'utf-8');
-    const stripped = raw.replace(/\/\/[^\n]*/g, '');
-    let settingsObj = {};
-    try {
-        settingsObj = JSON.parse(stripped);
-    }
-    catch {
-        // If we can't parse it (e.g. complex comments), push as-is
-        await fs.ensureDir(path.dirname(repoSettingsPath));
-        await fs.copy(localSettingsPath, repoSettingsPath, { overwrite: true });
+// Before every push, reconcile auto_install_extensions in settings.json against
+// the live extensions/index.json so that:
+//   - newly installed extensions (present in index, missing from the list) are added as true
+//   - uninstalled extensions (absent from index, set to true in the list) are removed
+//   - entries explicitly set to false by the user are always preserved (user intent)
+async function reconcileAutoInstallExtensions(localSettingsPath, localExtensionsIndexPath, silent = false) {
+    if (!(await fs.pathExists(localExtensionsIndexPath)))
         return;
-    }
-    delete settingsObj['auto_install_extensions'];
-    await fs.ensureDir(path.dirname(repoSettingsPath));
-    await fs.writeFile(repoSettingsPath, JSON.stringify(settingsObj, null, 4), 'utf-8');
-}
-// Extension merge helper
-async function applyRemoteSettings(repoSettings, repoExtensions, localSettingsPath, silent = false) {
-    // Backup existing settings
+    let settingsObj = {};
     if (await fs.pathExists(localSettingsPath)) {
-        await fs.copy(localSettingsPath, localSettingsPath + '.bak', { overwrite: true });
-        if (!silent)
-            p.log.info(`Backed up settings to ${color.dim(localSettingsPath + '.bak')}`);
-    }
-    let settingsJson = await fs.readFile(repoSettings, 'utf-8');
-    // Merge auto_install_extensions from index.json into settings
-    if (await fs.pathExists(repoExtensions)) {
         try {
-            const indexJson = (await fs.readJson(repoExtensions));
-            const extensionIds = Object.keys(indexJson.extensions ?? {}).filter(id => !indexJson.extensions[id]?.dev);
-            if (extensionIds.length > 0) {
-                const stripped = settingsJson.replace(/\/\/[^\n]*/g, '');
-                let settingsObj = {};
-                try {
-                    settingsObj = JSON.parse(stripped);
-                }
-                catch {
-                    if (!silent)
-                        p.log.warn(color.yellow('Could not parse settings.json — skipping extension merge.'));
-                }
-                // Preserve any existing entries (e.g. false entries for "never install"),
-                // then add true for every extension recorded in index.json.
-                const existing = typeof settingsObj['auto_install_extensions'] === 'object' &&
-                    settingsObj['auto_install_extensions'] !== null
-                    ? settingsObj['auto_install_extensions']
-                    : {};
-                const autoInstall = { ...existing };
-                for (const id of extensionIds) {
-                    // Only set to true if there is no explicit user preference already
-                    if (!(id in autoInstall)) {
-                        autoInstall[id] = true;
-                    }
-                }
-                settingsObj['auto_install_extensions'] = autoInstall;
-                settingsJson = JSON.stringify(settingsObj, null, 4);
-                if (!silent)
-                    p.log.info(`Injected ${color.cyan(String(extensionIds.length))} extension(s) into ${color.dim('auto_install_extensions')}`);
-            }
+            const raw = await fs.readFile(localSettingsPath, 'utf-8');
+            settingsObj = JSON.parse(raw.replace(/\/\/[^\n]*/g, ''));
         }
         catch {
             if (!silent)
-                p.log.warn(color.yellow('Could not parse extensions/index.json — skipping extension merge.'));
+                p.log.warn(color.yellow('Could not parse settings.json — skipping extension reconciliation.'));
+            return;
         }
     }
+    let installedIds = [];
+    try {
+        const indexJson = (await fs.readJson(localExtensionsIndexPath));
+        installedIds = Object.keys(indexJson.extensions ?? {}).filter(id => !indexJson.extensions[id]?.dev);
+    }
+    catch {
+        if (!silent)
+            p.log.warn(color.yellow('Could not parse extensions/index.json — skipping extension reconciliation.'));
+        return;
+    }
+    const existing = typeof settingsObj['auto_install_extensions'] === 'object' &&
+        settingsObj['auto_install_extensions'] !== null
+        ? settingsObj['auto_install_extensions']
+        : {};
+    const installedSet = new Set(installedIds);
+    const reconciled = {};
+    // Keep all explicit false entries (user said "never install this")
+    for (const [id, val] of Object.entries(existing)) {
+        if (val === false)
+            reconciled[id] = false;
+    }
+    // Add every currently installed extension as true
+    for (const id of installedIds) {
+        reconciled[id] = true;
+    }
+    // Drop true entries for extensions no longer installed
+    // (already handled — we only re-add what's in installedSet above)
+    const added = installedIds.filter(id => !(id in existing));
+    const removed = Object.keys(existing).filter(id => existing[id] === true && !installedSet.has(id));
+    if (added.length === 0 && removed.length === 0)
+        return;
+    settingsObj['auto_install_extensions'] = reconciled;
     await fs.ensureDir(path.dirname(localSettingsPath));
-    await fs.writeFile(localSettingsPath, settingsJson, 'utf-8');
+    await fs.writeFile(localSettingsPath, JSON.stringify(settingsObj, null, 4), 'utf-8');
+    if (!silent) {
+        if (added.length > 0)
+            p.log.info(`Added ${color.cyan(String(added.length))} new extension(s) to ${color.dim('auto_install_extensions')}: ${added.join(', ')}`);
+        if (removed.length > 0)
+            p.log.info(`Removed ${color.cyan(String(removed.length))} uninstalled extension(s) from ${color.dim('auto_install_extensions')}: ${removed.join(', ')}`);
+    }
 }
 // zedx sync status
 export async function syncStatus() {
@@ -138,14 +128,18 @@ export async function syncStatus() {
             {
                 repoPath: path.join(tmp, 'settings.json'),
                 localPath: zedPaths.settings,
-                label: 'settings.json',
+                label: 'Settings',
             },
             {
-                repoPath: path.join(tmp, 'extensions', 'index.json'),
-                localPath: zedPaths.extensions,
-                label: 'extensions/index.json',
+                repoPath: path.join(tmp, 'keymap.json'),
+                localPath: zedPaths.keymap,
+                label: 'Key bindings',
             },
         ];
+        // Track per-file actions needed for the outro message
+        const toPush = [];
+        const toPull = [];
+        const toResolve = [];
         for (const file of files) {
             const localExists = await fs.pathExists(file.localPath);
             const remoteFileExists = remoteExists && (await fs.pathExists(file.repoPath));
@@ -155,10 +149,12 @@ export async function syncStatus() {
             }
             if (localExists && !remoteFileExists) {
                 p.log.warn(`${color.bold(file.label)}: ${color.green('local only')} — not pushed yet`);
+                toPush.push(file.label);
                 continue;
             }
             if (!localExists && remoteFileExists) {
                 p.log.warn(`${color.bold(file.label)}: ${color.cyan('remote only')} — not pulled yet`);
+                toPull.push(file.label);
                 continue;
             }
             const localContent = await fs.readFile(file.localPath, 'utf-8');
@@ -174,16 +170,34 @@ export async function syncStatus() {
             const remoteChanged = !lastSync || remoteMtime > lastSync;
             if (localChanged && !remoteChanged) {
                 p.log.warn(`${color.bold(file.label)}: ${color.green('local ahead')} — modified ${color.dim(localMtime.toLocaleString())}`);
+                toPush.push(file.label);
             }
             else if (remoteChanged && !localChanged) {
                 p.log.warn(`${color.bold(file.label)}: ${color.cyan('remote ahead')} — modified ${color.dim(remoteMtime.toLocaleString())}`);
+                toPull.push(file.label);
             }
             else {
                 p.log.warn(`${color.bold(file.label)}: ${color.yellow('conflict')} — both changed since last sync`);
+                toResolve.push(file.label);
             }
         }
+        const singleAction = [toPush, toPull, toResolve].filter(a => a.length > 0).length === 1;
+        const needsSync = toPush.length > 0 || toPull.length > 0 || toResolve.length > 0;
+        if (needsSync) {
+            if (singleAction && toPush.length > 0) {
+                p.outro(`Run ${color.cyan('zedx sync')} to push ${toPush.map(l => color.bold(l)).join(', ')} to remote.`);
+            }
+            else if (singleAction && toPull.length > 0) {
+                p.outro(`Run ${color.cyan('zedx sync')} to pull ${toPull.map(l => color.bold(l)).join(', ')} from remote.`);
+            }
+            else {
+                p.outro(`Run ${color.cyan('zedx sync')} to resolve.`);
+            }
+        }
+        else {
+            p.outro('Everything is in sync.');
+        }
     });
-    p.outro(`Run ${color.cyan('zedx sync')} to resolve.`);
 }
 // zedx sync init
 export async function syncInit() {
@@ -231,9 +245,38 @@ export async function syncInit() {
     p.outro(`${color.green('✓')} Sync config saved to ${color.cyan(ZEDX_CONFIG_PATH)}\n\n` +
         `  Run ${color.cyan('zedx sync')} to sync your Zed config.`);
 }
+// zedx sync select
+export async function syncSelect() {
+    console.log('');
+    p.intro(`${color.bgBlue(color.bold(' zedx sync select '))} ${color.blue('Choose which files to sync…')}`);
+    await requireSyncConfig();
+    const allFiles = [
+        {
+            value: 'settings',
+            label: 'Settings',
+            hint: 'settings.json',
+        },
+        {
+            value: 'keymap',
+            label: 'Key bindings',
+            hint: 'keymap.json',
+        },
+    ];
+    const selected = await p.multiselect({
+        message: 'Select files to sync',
+        options: allFiles,
+        required: true,
+    });
+    if (p.isCancel(selected)) {
+        p.cancel('Cancelled.');
+        process.exit(0);
+    }
+    const selectedFiles = selected;
+    await runSync({ selectedFiles });
+}
 // zedx sync
 export async function runSync(opts = {}) {
-    const { silent = false } = opts;
+    const { silent = false, conflict = 'prompt', selectedFiles } = opts;
     // In silent mode (daemon/watch), route all UI through plain console.log
     // Interactive conflict prompts fall back to "local wins".
     const log = {
@@ -254,7 +297,7 @@ export async function runSync(opts = {}) {
     };
     if (!silent) {
         console.log('');
-        p.intro(`${color.bgBlue(color.bold(' zedx sync '))} ${color.blue('Syncing Zed settings and extensions…')}`);
+        p.intro(`${color.bgBlue(color.bold(' zedx sync '))} ${color.blue('Syncing Zed config…')}`);
     }
     const config = await requireSyncConfig();
     const zedPaths = resolveZedPaths();
@@ -282,18 +325,23 @@ export async function runSync(opts = {}) {
         }
         // 2. Determine what changed for each file
         const lastSync = config.lastSync ? new Date(config.lastSync) : null;
-        const files = [
+        const allFiles = [
             {
+                key: 'settings',
                 repoPath: path.join(tmp, 'settings.json'),
                 localPath: zedPaths.settings,
-                label: 'settings.json',
+                label: 'Settings',
             },
             {
-                repoPath: path.join(tmp, 'extensions', 'index.json'),
-                localPath: zedPaths.extensions,
-                label: 'extensions/index.json',
+                key: 'keymap',
+                repoPath: path.join(tmp, 'keymap.json'),
+                localPath: zedPaths.keymap,
+                label: 'Key bindings',
             },
         ];
+        const files = selectedFiles
+            ? allFiles.filter(f => selectedFiles.includes(f.key))
+            : allFiles;
         let anyChanges = false;
         for (const file of files) {
             const localExists = await fs.pathExists(file.localPath);
@@ -303,29 +351,27 @@ export async function runSync(opts = {}) {
                 log.warn(`${file.label}: not found locally or remotely — skipping.`);
                 continue;
             }
-            // Remote doesn't have it yet — push local
+            // Remote doesn't have it yet — first push.
+            // Bootstrap auto_install_extensions from local extensions/index.json so
+            // the synced settings.json is self-contained on a fresh machine.
             if (localExists && !remoteFileExists) {
                 log.info(`${file.label}: ${color.green('pushing')} (not in remote yet)`);
-                if (file.label === 'settings.json') {
-                    await prepareSettingsForPush(file.localPath, file.repoPath);
-                }
-                else {
-                    await fs.ensureDir(path.dirname(file.repoPath));
-                    await fs.copy(file.localPath, file.repoPath, { overwrite: true });
-                }
+                await reconcileAutoInstallExtensions(file.localPath, zedPaths.extensionsIndex, silent);
+                await fs.ensureDir(path.dirname(file.repoPath));
+                await fs.copy(file.localPath, file.repoPath, { overwrite: true });
                 anyChanges = true;
                 continue;
             }
             // Local doesn't have it — pull remote
             if (!localExists && remoteFileExists) {
                 log.info(`${file.label}: ${color.cyan('pulling')} (not found locally)`);
-                if (file.label === 'settings.json') {
-                    await applyRemoteSettings(file.repoPath, path.join(tmp, 'extensions', 'index.json'), file.localPath, silent);
-                }
-                else {
-                    await fs.ensureDir(path.dirname(file.localPath));
-                    await fs.copy(file.repoPath, file.localPath, { overwrite: true });
+                if (await fs.pathExists(file.localPath)) {
+                    await fs.copy(file.localPath, file.localPath + '.bak', { overwrite: true });
+                    if (!silent)
+                        p.log.info(`Backed up settings to ${color.dim(file.localPath + '.bak')}`);
                 }
+                await fs.ensureDir(path.dirname(file.localPath));
+                await fs.copy(file.repoPath, file.localPath, { overwrite: true });
                 continue;
             }
             // Both exist — compare content
@@ -343,41 +389,36 @@ export async function runSync(opts = {}) {
             const localChanged = !lastSync || localMtime > lastSync;
             const remoteChanged = !lastSync || remoteMtime > lastSync;
             if (localChanged && !remoteChanged) {
-                // Only local changed → push
+                // Only local changed → reconcile extensions then push
                 log.info(`${file.label}: ${color.green('pushing')} (local is newer)`);
-                if (file.label === 'settings.json') {
-                    await prepareSettingsForPush(file.localPath, file.repoPath);
-                }
-                else {
-                    await fs.ensureDir(path.dirname(file.repoPath));
-                    await fs.copy(file.localPath, file.repoPath, { overwrite: true });
-                }
+                await reconcileAutoInstallExtensions(file.localPath, zedPaths.extensionsIndex, silent);
+                await fs.ensureDir(path.dirname(file.repoPath));
+                await fs.copy(file.localPath, file.repoPath, { overwrite: true });
                 anyChanges = true;
             }
             else if (remoteChanged && !localChanged) {
                 // Only remote changed → pull
                 log.info(`${file.label}: ${color.cyan('pulling')} (remote is newer)`);
-                if (file.label === 'settings.json') {
-                    await applyRemoteSettings(file.repoPath, path.join(tmp, 'extensions', 'index.json'), file.localPath, silent);
-                }
-                else {
-                    await fs.ensureDir(path.dirname(file.localPath));
-                    await fs.copy(file.repoPath, file.localPath, { overwrite: true });
-                }
+                await fs.copy(file.localPath, file.localPath + '.bak', { overwrite: true });
+                if (!silent)
+                    p.log.info(`Backed up settings to ${color.dim(file.localPath + '.bak')}`);
+                await fs.copy(file.repoPath, file.localPath, { overwrite: true });
             }
             else {
-                // Both changed
-                if (silent) {
+                // Both changed — resolve based on strategy
+                // Determine the effective resolution:
+                //   - explicit --local / --remote flag always wins
+                //   - silent (daemon) mode falls back to local
+                //   - otherwise prompt interactively
+                let resolution;
+                if (conflict === 'local' || conflict === 'remote') {
+                    resolution = conflict;
+                    log.warn(`${file.label}: conflict — using ${color.bold(resolution)} (--${resolution} flag).`);
+                }
+                else if (silent) {
                     // Daemon can't prompt — local wins, will be pushed
+                    resolution = 'local';
                     log.warn(`${file.label}: conflict detected in unattended mode — keeping local.`);
-                    if (file.label === 'settings.json') {
-                        await prepareSettingsForPush(file.localPath, file.repoPath);
-                    }
-                    else {
-                        await fs.ensureDir(path.dirname(file.repoPath));
-                        await fs.copy(file.localPath, file.repoPath, { overwrite: true });
-                    }
-                    anyChanges = true;
                 }
                 else {
                     p.log.warn(color.yellow(`conflict between local and remote ${file.label}`));
@@ -400,34 +441,30 @@ export async function runSync(opts = {}) {
                         p.cancel('Cancelled.');
                         process.exit(0);
                     }
-                    if (choice === 'local') {
+                    resolution = choice;
+                }
+                if (resolution === 'local') {
+                    if (!silent && conflict === 'prompt')
                         p.log.info(`${file.label}: ${color.green('keeping local, will push')}`);
-                        if (file.label === 'settings.json') {
-                            await prepareSettingsForPush(file.localPath, file.repoPath);
-                        }
-                        else {
-                            await fs.ensureDir(path.dirname(file.repoPath));
-                            await fs.copy(file.localPath, file.repoPath, { overwrite: true });
-                        }
-                        anyChanges = true;
-                    }
-                    else {
+                    await reconcileAutoInstallExtensions(file.localPath, zedPaths.extensionsIndex, silent);
+                    await fs.ensureDir(path.dirname(file.repoPath));
+                    await fs.copy(file.localPath, file.repoPath, { overwrite: true });
+                    anyChanges = true;
+                }
+                else {
+                    if (!silent && conflict === 'prompt')
                         p.log.info(`${file.label}: ${color.cyan('applying remote')}`);
-                        if (file.label === 'settings.json') {
-                            await applyRemoteSettings(file.repoPath, path.join(tmp, 'extensions', 'index.json'), file.localPath, silent);
-                        }
-                        else {
-                            await fs.ensureDir(path.dirname(file.localPath));
-                            await fs.copy(file.repoPath, file.localPath, { overwrite: true });
-                        }
-                    }
+                    await fs.copy(file.localPath, file.localPath + '.bak', { overwrite: true });
+                    if (!silent)
+                        p.log.info(`Backed up settings to ${color.dim(file.localPath + '.bak')}`);
+                    await fs.copy(file.repoPath, file.localPath, { overwrite: true });
                 }
             }
         }
         // 3. Commit + push if any local files were written to the repo
         if (anyChanges) {
             spinner.start('Pushing changes to remote...');
-            await git.add(['settings.json', path.join('extensions', 'index.json')]);
+            await git.add(files.map(f => path.basename(f.repoPath)));
             const status = await git.status();
             if (status.staged.length > 0) {
                 const timestamp = new Date().toISOString();

package/dist/types/index.d.ts

@@ -1,7 +1,8 @@
 export type ExtensionType = 'theme' | 'language';
 export interface ZedPaths {
     settings: string;
-    extensions: string;
+    keymap: string;
+    extensionsIndex: string;
 }
 export interface SyncConfig {
     syncRepo: string;

package/dist/zed-paths.js

@@ -4,26 +4,32 @@ export function resolveZedPaths() {
     const home = os.homedir();
     const platform = process.platform;
     if (platform === 'darwin') {
+        const configDir = path.join(home, '.config', 'zed');
         return {
-            settings: path.join(home, '.config', 'zed', 'settings.json'),
-            extensions: path.join(home, 'Library', 'Application Support', 'Zed', 'extensions', 'index.json'),
+            settings: path.join(configDir, 'settings.json'),
+            keymap: path.join(configDir, 'keymap.json'),
+            extensionsIndex: path.join(home, 'Library', 'Application Support', 'Zed', 'extensions', 'index.json'),
         };
     }
     if (platform === 'linux') {
         const xdgData = process.env.FLATPAK_XDG_DATA_HOME ||
             process.env.XDG_DATA_HOME ||
             path.join(home, '.local', 'share');
+        const configDir = path.join(home, '.config', 'zed');
         return {
-            settings: path.join(home, '.config', 'zed', 'settings.json'),
-            extensions: path.join(xdgData, 'zed', 'extensions', 'index.json'),
+            settings: path.join(configDir, 'settings.json'),
+            keymap: path.join(configDir, 'keymap.json'),
+            extensionsIndex: path.join(xdgData, 'zed', 'extensions', 'index.json'),
         };
     }
     if (platform === 'win32') {
         const appData = process.env.APPDATA || path.join(home, 'AppData', 'Roaming');
         const localAppData = process.env.LOCALAPPDATA || path.join(home, 'AppData', 'Local');
+        const configDir = path.join(appData, 'Zed');
         return {
-            settings: path.join(appData, 'Zed', 'settings.json'),
-            extensions: path.join(localAppData, 'Zed', 'extensions', 'index.json'),
+            settings: path.join(configDir, 'settings.json'),
+            keymap: path.join(configDir, 'keymap.json'),
+            extensionsIndex: path.join(localAppData, 'Zed', 'extensions', 'index.json'),
         };
     }
     throw new Error(`Unsupported platform: ${platform}`);

package/package.json

@@ -1,11 +1,13 @@
 {
     "name": "zedx",
-    "version": "0.8.1",
-    "description": "Scaffold Zed Editor extensions and sync your settings across machines.",
+    "version": "0.10.0",
+    "description": "The CLI toolkit for Zed Editor.",
     "keywords": [
         "boilerplate",
         "extension",
         "scaffold",
+        "settings",
+        "sync",
         "zed",
         "zed-editor"
     ],