feat: handle store config conflicts during git pull

Resolve remote name dynamically from branch tracking config instead of
hardcoding 'origin'. Detect and surface sync-settings.json / machines.json
conflicts after pull, with a dialog for manual resolution. Auto-commit
config file writes so changes are tracked in store git history.

Author: dinhanhthi

README.md

@@ -77,6 +77,7 @@ pnpm install && pnpm build && pnpm start
 On the setup screen, point to your existing data directory (clone your store repo first if needed).
 
 The app will automatically:
+
 - Assign a unique machine ID and name (based on hostname)
 - Restore all shared settings from `sync-settings.json`
 - Auto-link repos and services that have known paths for this machine

packages/server/src/routes/sync.ts

@@ -2,7 +2,13 @@ import type { FastifyInstance } from 'fastify';
 import type { SyncLogEntry } from '../types/index.js';
 import type { AppState } from '../app-state.js';
 import { mapRows } from '../db/index.js';
-import { pullStoreChanges, pushStoreChanges, getStoreRemoteUrl } from '../services/store-git.js';
+import {
+  pullStoreChanges,
+  pushStoreChanges,
+  getStoreRemoteUrl,
+  resolveStoreConfigConflict,
+} from '../services/store-git.js';
+import { restoreSettingsFromFile } from '../services/sync-settings.js';
 
 interface SyncLogEntryWithRepo extends SyncLogEntry {
   repoName: string | null;
@@ -30,6 +36,39 @@ export function registerSyncRoutes(app: FastifyInstance, state: AppState): void
     }
   });
 
+  // Resolve a store config conflict (sync-settings.json or machines.json)
+  app.post<{
+    Params: { file: string };
+    Body: { content: string };
+  }>('/api/store/resolve-config/:file', async (req, reply) => {
+    if (!state.db) return reply.code(503).send({ error: 'Not configured' });
+    const db = state.db;
+
+    const file = req.params.file;
+    if (file !== 'sync-settings.json' && file !== 'machines.json') {
+      return reply.code(400).send({ error: 'Invalid file name' });
+    }
+
+    const { content } = req.body;
+    if (typeof content !== 'string') {
+      return reply.code(400).send({ error: 'Missing content' });
+    }
+
+    try {
+      await resolveStoreConfigConflict(file, content);
+
+      // Reload settings into DB if sync-settings.json was resolved
+      if (file === 'sync-settings.json') {
+        restoreSettingsFromFile(db);
+      }
+
+      return { resolved: true };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : 'Resolve failed';
+      return reply.code(500).send({ error: message });
+    }
+  });
+
   // Push store changes to remote
   app.post('/api/store/push', async (_req, reply) => {
     if (!state.db) return reply.code(503).send({ error: 'Not configured' });

packages/server/src/services/machines.ts

@@ -21,6 +21,7 @@ import { getRepoEnabledFilePatterns } from '../db/index.js';
 import { applyOverridesForRepo, applyOverridesForService } from './sync-settings.js';
 import { getServiceDefinition, registerCustomDefinition } from './service-definitions.js';
 import { scanServiceFiles } from './service-scanner.js';
+import { queueStoreCommit } from './store-git.js';
 
 const MACHINES_FILE = 'machines.json';
 
@@ -56,6 +57,7 @@ export function writeMachinesFile(data: MachinesFile): void {
     services: sortKeys(data.services),
   };
   fs.writeFileSync(filePath, JSON.stringify(sorted, null, 2) + '\n', 'utf-8');
+  queueStoreCommit('Update machines.json');
 }
 
 function sortKeys<T>(obj: Record<string, T>): Record<string, T> {

packages/server/src/services/store-git.ts

@@ -196,17 +196,126 @@ async function resolveRemote(): Promise<string | null> {
   return remotes.find((r) => r.name === 'origin')?.name ?? remotes[0].name;
 }
 
-export async function pullStoreChanges(): Promise<{ pulled: boolean; message: string }> {
+export interface StoreConfigConflict {
+  file: 'sync-settings.json' | 'machines.json';
+  content: string; // raw content with git conflict markers
+  ours: string; // content of the "ours" (HEAD) side
+  theirs: string; // content of the "theirs" (incoming) side
+}
+
+export interface PullResult {
+  pulled: boolean;
+  message: string;
+  storeConflicts?: StoreConfigConflict[];
+}
+
+/** Parse conflict markers from a conflicted file, returning ours and theirs content. */
+function parseConflictSides(content: string): { ours: string; theirs: string } {
+  // Collect lines from each side by scanning conflict blocks
+  const oursLines: string[] = [];
+  const theirsLines: string[] = [];
+  let inOurs = false;
+  let inTheirs = false;
+
+  for (const line of content.split('\n')) {
+    if (line.startsWith('<<<<<<<')) {
+      inOurs = true;
+      inTheirs = false;
+    } else if (line.startsWith('=======')) {
+      inOurs = false;
+      inTheirs = true;
+    } else if (line.startsWith('>>>>>>>')) {
+      inOurs = false;
+      inTheirs = false;
+    } else if (inOurs) {
+      oursLines.push(line);
+    } else if (inTheirs) {
+      theirsLines.push(line);
+    } else {
+      // Context lines outside conflict blocks — include in both
+      oursLines.push(line);
+      theirsLines.push(line);
+    }
+  }
+
+  return { ours: oursLines.join('\n'), theirs: theirsLines.join('\n') };
+}
+
+export async function pullStoreChanges(): Promise<PullResult> {
   const remote = await resolveRemote();
   if (!remote) {
     return { pulled: false, message: 'No remote configured' };
   }
 
-  const branch = await git!.branchLocal();
-  await git!.pull(remote, branch.current);
+  if (!git) {
+    git = createGit(config.storePath);
+  }
+
+  const branch = await git.branchLocal();
+  try {
+    await git.pull(remote, branch.current);
+  } catch (err) {
+    // If git pull itself throws (e.g. merge conflict), check status for conflicted files
+    const status = await git.status();
+    const conflictedPaths = status.conflicted;
+
+    const knownConfigFiles = ['sync-settings.json', 'machines.json'] as const;
+    const storeConflicts: StoreConfigConflict[] = [];
+
+    for (const filePath of conflictedPaths) {
+      const basename = path.basename(filePath) as (typeof knownConfigFiles)[number];
+      if (!knownConfigFiles.includes(basename)) continue;
+
+      const fullPath = path.join(config.storePath, filePath);
+      let content = '';
+      try {
+        content = await fs.readFile(fullPath, 'utf-8');
+      } catch {
+        continue;
+      }
+
+      const { ours, theirs } = parseConflictSides(content);
+      storeConflicts.push({ file: basename, content, ours, theirs });
+    }
+
+    if (storeConflicts.length > 0) {
+      return {
+        pulled: true,
+        message: `Pulled from ${remote}/${branch.current} with config conflicts`,
+        storeConflicts,
+      };
+    }
+
+    // Re-throw if no config conflicts (other errors like network issues)
+    throw err;
+  }
+
   return { pulled: true, message: `Pulled from ${remote}/${branch.current}` };
 }
 
+/**
+ * Resolve a store config conflict by writing the chosen content to disk,
+ * then staging and committing the resolution.
+ */
+export async function resolveStoreConfigConflict(
+  file: 'sync-settings.json' | 'machines.json',
+  content: string,
+): Promise<void> {
+  if (!git) {
+    git = createGit(config.storePath);
+  }
+
+  const fullPath = path.join(config.storePath, file);
+  await fs.writeFile(fullPath, content, 'utf-8');
+  await git.add(file);
+
+  // Check if all conflicts are resolved before committing
+  const status = await git.status();
+  if (status.conflicted.length === 0) {
+    await git.commit(`Resolve conflict in ${file}`);
+  }
+}
+
 export async function pushStoreChanges(): Promise<{ pushed: boolean; message: string }> {
   const remote = await resolveRemote();
   if (!remote) {

packages/server/src/services/sync-settings.ts

@@ -6,6 +6,7 @@ import { config } from '../config.js';
 import { mapRows } from '../db/index.js';
 import { DEFAULT_SETTINGS } from '../db/schema.js';
 import type { Repo, ServiceConfig } from '../types/index.js';
+import { queueStoreCommit } from './store-git.js';
 
 // ── Types ────────────────────────────────────────────────────────────
 
@@ -136,6 +137,7 @@ export function writeSyncSettingsFile(data: SyncSettingsFile): void {
   };
 
   fs.writeFileSync(filePath, JSON.stringify(sorted, null, 2) + '\n', 'utf-8');
+  queueStoreCommit('Update sync-settings.json');
 }
 
 // ── Read DB state into file sections ─────────────────────────────────

packages/ui/src/components/layout.tsx

@@ -1,5 +1,5 @@
 import { Button } from '@/components/ui/button';
-import { api } from '@/lib/api';
+import { api, type StoreConfigConflict } from '@/lib/api';
 import { cn } from '@/lib/utils';
 import {
   Database,
@@ -17,6 +17,7 @@ import { useEffect, useRef, useState } from 'react';
 import { Link, useLocation } from 'react-router-dom';
 import { toast } from 'sonner';
 import { ConfirmDialog } from './confirm-dialog';
+import { StoreConfigConflictDialog } from './store-config-conflict-dialog';
 import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from './ui/tooltip';
 import { UpdateBanner } from './update-banner';
 import { useMachine } from '@/hooks/use-machines';
@@ -36,6 +37,9 @@ export function Layout({ children, dataDir }: { children: React.ReactNode; dataD
   const [resetOpen, setResetOpen] = useState(false);
   const [resetting, setResetting] = useState(false);
   const [remoteUrl, setRemoteUrl] = useState<string | null>(null);
+  const [storeConfigConflicts, setStoreConfigConflicts] = useState<StoreConfigConflict[] | null>(
+    null,
+  );
   const { machineName } = useMachine();
 
   useEffect(() => {
@@ -86,7 +90,10 @@ export function Layout({ children, dataDir }: { children: React.ReactNode; dataD
     setPulling(true);
     try {
       const result = await api.store.pull();
-      if (result.pulled) {
+      if (result.storeConflicts && result.storeConflicts.length > 0) {
+        setStoreConfigConflicts(result.storeConflicts);
+        toast.warning('Pull completed with config conflicts — please resolve them');
+      } else if (result.pulled) {
         toast.success(result.message);
       } else {
         toast.warning(result.message);
@@ -296,6 +303,13 @@ export function Layout({ children, dataDir }: { children: React.ReactNode; dataD
         description="Push all committed store changes to the remote repository?"
         confirmLabel="Push"
       />
+
+      {storeConfigConflicts && storeConfigConflicts.length > 0 && (
+        <StoreConfigConflictDialog
+          conflicts={storeConfigConflicts}
+          onResolved={() => setStoreConfigConflicts(null)}
+        />
+      )}
     </div>
   );
 }