@openchambery/web 1.18.2-beta.1 → 1.18.2-beta.3

package/server/lib/config-sync/scripts.js

@@ -0,0 +1,264 @@
+import path from 'node:path';
+
+import {
+  OPENCODE_AGENTS_ROOT_PROBE_MARKER,
+  OPENCODE_AGENTS_SYNC_BACKUP_DIR,
+  OPENCODE_AUTH_FILE_PROBE_MARKER,
+  OPENCODE_AUTH_SYNC_BACKUP_DIR,
+  OPENCODE_CONFIG_SYNC_ALLOWLIST,
+  OPENCODE_CONFIG_SYNC_BACKUP_DIR,
+  OPENCODE_CONFIG_SYNC_BACKUP_GENERATIONS,
+} from './constants.js';
+
+const shellQuote = (value) => `'${String(value).replace(/'/g, `'\\''`)}'`;
+
+/**
+ * Sanitize syncRunId for use as a single path segment under backup roots.
+ * @param {string} syncRunId
+ */
+export const sanitizeSyncRunIdForPath = (syncRunId) => {
+  const trimmed = String(syncRunId || '').trim();
+  if (!trimmed) throw new Error('syncRunId is required for generational backup');
+  if (!/^[A-Za-z0-9._-]+$/.test(trimmed)) {
+    throw new Error('syncRunId contains unsupported characters for backup paths');
+  }
+  return trimmed;
+};
+
+/**
+ * Emit POSIX lines that create `<$backupVar>/<syncRunId>` as `$runVar` and prune older generations.
+ * Does not wipe the entire backup root — only replaces the current run dir and
+ * deletes generations beyond the retention limit (failed runs keep their scene).
+ *
+ * @param {{ backupVar: string, runVar: string, quotedRunId: string, generations: number }} args
+ * @returns {string[]}
+ */
+const generationalBackupSetupLines = ({ backupVar, runVar, quotedRunId, generations }) => [
+  `mkdir -p "$${backupVar}"`,
+  `${runVar}="$${backupVar}"/${quotedRunId}`,
+  `rm -rf -- "$${runVar}"`,
+  `mkdir -p "$${runVar}"`,
+  `(cd "$${backupVar}" && ls -1t 2>/dev/null | awk 'NR>${generations} {print}' | while IFS= read -r old; do`,
+  '  [ -n "$old" ] || continue',
+  `  [ "$old" = ${quotedRunId} ] && continue`,
+  `  rm -rf -- "$${backupVar}/$old"`,
+  'done) || true',
+];
+
+/**
+ * Build the remote POSIX prepare script: generational backup, delete stale counterparts, print SYNC_READY.
+ * Backups land under `<backupRoot>/<syncRunId>/…`. Older generations beyond
+ * {@link OPENCODE_CONFIG_SYNC_BACKUP_GENERATIONS} are pruned; prepare no longer
+ * `rm -rf`s the entire backup root at start.
+ *
+ * @param {{ files: { path: string }[], directories: { path: string }[], deletes: string[], agentsRoot?: { fileCount: number, bytes: number } | null, authFile?: { bytes: number } | null }} plan
+ * @param {{ syncRunId: string, generations?: number }} options
+ * @returns {string}
+ */
+export const buildRemoteSyncPrepareScript = (plan, options) => {
+  const syncRunId = sanitizeSyncRunIdForPath(options?.syncRunId);
+  const generations = Number.isFinite(options?.generations) && Number(options.generations) > 0
+    ? Math.trunc(Number(options.generations))
+    : OPENCODE_CONFIG_SYNC_BACKUP_GENERATIONS;
+  const backupDir = OPENCODE_CONFIG_SYNC_BACKUP_DIR;
+  const directoryDeleteNames = new Set();
+  for (const dirSpec of OPENCODE_CONFIG_SYNC_ALLOWLIST.directories) {
+    directoryDeleteNames.add(dirSpec.path);
+    if (typeof dirSpec.legacy === 'string' && dirSpec.legacy) {
+      directoryDeleteNames.add(dirSpec.legacy);
+    }
+  }
+
+  const quotedRunId = shellQuote(syncRunId);
+  const lines = [
+    'set -e',
+    'CFG="$HOME/.config/opencode"',
+    'mkdir -p "$CFG"',
+    `BK="$CFG/${backupDir}"`,
+    ...generationalBackupSetupLines({
+      backupVar: 'BK',
+      runVar: 'RUN_BK',
+      quotedRunId,
+      generations,
+    }),
+  ];
+
+  const backupPaths = [
+    ...(Array.isArray(plan?.files) ? plan.files.map((entry) => entry.path) : []),
+    ...(Array.isArray(plan?.directories) ? plan.directories.map((entry) => entry.path) : []),
+  ];
+
+  for (const rel of backupPaths) {
+    const quoted = shellQuote(rel);
+    const dirname = path.posix.dirname(rel);
+    const quotedDir = shellQuote(dirname === '.' ? '' : dirname);
+    lines.push(`if [ -e "$CFG"/${quoted} ]; then`);
+    if (dirname === '.' || dirname === '') {
+      lines.push('  mkdir -p "$RUN_BK"');
+    } else {
+      lines.push(`  mkdir -p "$RUN_BK"/${quotedDir}`);
+    }
+    lines.push(`  cp -a "$CFG"/${quoted} "$RUN_BK"/${quoted}`);
+    lines.push('fi');
+  }
+
+  for (const rel of Array.isArray(plan?.deletes) ? plan.deletes : []) {
+    const quoted = shellQuote(rel);
+    if (directoryDeleteNames.has(rel)) {
+      lines.push(`rm -rf -- "$CFG"/${quoted}`);
+    } else {
+      lines.push(`rm -f -- "$CFG"/${quoted}`);
+    }
+  }
+
+  if (plan?.agentsRoot) {
+    lines.push(`AGENTS_BK="$HOME/${OPENCODE_AGENTS_SYNC_BACKUP_DIR}"`);
+    lines.push(...generationalBackupSetupLines({
+      backupVar: 'AGENTS_BK',
+      runVar: 'AGENTS_RUN_BK',
+      quotedRunId,
+      generations,
+    }));
+    lines.push('if [ -e "$HOME/.agents" ]; then');
+    lines.push('  cp -a "$HOME/.agents" "$AGENTS_RUN_BK/agents"');
+    lines.push('fi');
+    lines.push('rm -rf -- "$HOME/.agents"');
+  }
+
+  if (plan?.authFile) {
+    lines.push(`AUTH_BK="$HOME/${OPENCODE_AUTH_SYNC_BACKUP_DIR}"`);
+    lines.push(...generationalBackupSetupLines({
+      backupVar: 'AUTH_BK',
+      runVar: 'AUTH_RUN_BK',
+      quotedRunId,
+      generations,
+    }));
+    lines.push('if [ -e "$HOME/.local/share/opencode/auth.json" ]; then');
+    lines.push('  cp -a "$HOME/.local/share/opencode/auth.json" "$AUTH_RUN_BK/auth.json"');
+    lines.push('fi');
+  }
+
+  lines.push("printf 'SYNC_READY\\n'");
+  return lines.join('\n');
+};
+
+/**
+ * Build the remote existence probe script for the sync preview.
+ * @param {string[]} uniqueProbePaths
+ * @returns {string}
+ */
+export const buildRemoteSyncProbeScript = (uniqueProbePaths) => {
+  const lines = (Array.isArray(uniqueProbePaths) ? uniqueProbePaths : []).map((rel) => {
+    const quoted = shellQuote(rel);
+    return `[ -e "$HOME/.config/opencode"/${quoted} ] && printf '%s\\n' ${quoted}`;
+  });
+  lines.push(
+    `[ -e "$HOME/.agents" ] && printf '%s\\n' ${shellQuote(OPENCODE_AGENTS_ROOT_PROBE_MARKER)}`,
+  );
+  lines.push(
+    `[ -e "$HOME/.local/share/opencode/auth.json" ] && printf '%s\\n' ${shellQuote(OPENCODE_AUTH_FILE_PROBE_MARKER)}`,
+  );
+  lines.push('exit 0');
+  return lines.join('\n');
+};
+
+/**
+ * Finalize script: confirm generational backup dir exists for this syncRunId and print SYNC_DONE.
+ * @param {{ syncRunId: string }} options
+ */
+export const buildRemoteSyncFinalizeScript = (options) => {
+  const syncRunId = sanitizeSyncRunIdForPath(options?.syncRunId);
+  const quotedRunId = shellQuote(syncRunId);
+  return [
+    'set -e',
+    `BK="$HOME/.config/opencode/${OPENCODE_CONFIG_SYNC_BACKUP_DIR}"/${quotedRunId}`,
+    'if [ ! -d "$BK" ]; then',
+    "  printf 'SYNC_FINALIZE_MISSING_BACKUP\\n' >&2",
+    '  exit 1',
+    'fi',
+    "printf 'SYNC_DONE\\n'",
+  ].join('\n');
+};
+
+/**
+ * Build a remote inventory script that prints a JSON object describing which
+ * allowlist paths exist on the remote (for pull planning). Uses only POSIX sh.
+ * Output is a single JSON line prefixed by SYNC_INVENTORY=.
+ * @returns {string}
+ */
+export const buildRemoteSyncInventoryScript = () => {
+  const filePaths = [
+    ...OPENCODE_CONFIG_SYNC_ALLOWLIST.fileGroups.flat(),
+    ...OPENCODE_CONFIG_SYNC_ALLOWLIST.singleFiles,
+  ];
+  const dirPaths = OPENCODE_CONFIG_SYNC_ALLOWLIST.directories.map((entry) => entry.path);
+  const lines = [
+    'set -e',
+    'CFG="$HOME/.config/opencode"',
+    'FILES=""',
+    'DIRS=""',
+  ];
+  for (const rel of filePaths) {
+    const quoted = shellQuote(rel);
+    lines.push(`if [ -f "$CFG"/${quoted} ]; then`);
+    lines.push(`  BYTES="$(wc -c < "$CFG"/${quoted} | tr -d ' ')"`);
+    lines.push(`  FILES="$FILES{\\"path\\":${JSON.stringify(rel)},\\"bytes\\":$BYTES},"`);
+    lines.push('fi');
+  }
+  for (const rel of dirPaths) {
+    const quoted = shellQuote(rel);
+    lines.push(`if [ -d "$CFG"/${quoted} ]; then`);
+    lines.push(`  COUNT="$(find "$CFG"/${quoted} -type f ! -path '*/node_modules/*' ! -name '*.backup' 2>/dev/null | wc -l | tr -d ' ')"`);
+    lines.push(`  BYTES="$(find "$CFG"/${quoted} -type f ! -path '*/node_modules/*' ! -name '*.backup' -exec wc -c {} + 2>/dev/null | awk 'END{print $1+0}')"`);
+    lines.push(`  DIRS="$DIRS{\\"path\\":${JSON.stringify(rel)},\\"fileCount\\":$COUNT,\\"bytes\\":$BYTES},"`);
+    lines.push('fi');
+  }
+  lines.push('AGENTS="null"');
+  lines.push('if [ -d "$HOME/.agents" ]; then');
+  lines.push("  ACOUNT=\"$(find \"$HOME/.agents\" -type f ! -path '*/node_modules/*' ! -name '*.backup' 2>/dev/null | wc -l | tr -d ' ')\"");
+  lines.push("  ABYTES=\"$(find \"$HOME/.agents\" -type f ! -path '*/node_modules/*' ! -name '*.backup' -exec wc -c {} + 2>/dev/null | awk 'END{print $1+0}')\"");
+  lines.push('  AGENTS="{\\"fileCount\\":$ACOUNT,\\"bytes\\":$ABYTES}"');
+  lines.push('fi');
+  lines.push('AUTH="null"');
+  lines.push('if [ -f "$HOME/.local/share/opencode/auth.json" ]; then');
+  lines.push('  AUBYTES="$(wc -c < "$HOME/.local/share/opencode/auth.json" | tr -d \' \')"');
+  lines.push('  AUTH="{\\"bytes\\":$AUBYTES}"');
+  lines.push('fi');
+  lines.push('FILES="${FILES%,}"');
+  lines.push('DIRS="${DIRS%,}"');
+  lines.push('printf \'SYNC_INVENTORY={"files":[%s],"directories":[%s],"agentsRoot":%s,"authFile":%s}\\n\' "$FILES" "$DIRS" "$AGENTS" "$AUTH"');
+  lines.push('exit 0');
+  return lines.join('\n');
+};
+
+/**
+ * Stream a remote tar.gz of selected config paths to stdout.
+ * @param {{ files?: { path: string }[], directories?: { path: string }[] }} plan
+ */
+export const buildRemoteConfigTarScript = (plan) => {
+  const entries = [
+    ...(Array.isArray(plan?.files) ? plan.files.map((entry) => entry.path) : []),
+    ...(Array.isArray(plan?.directories) ? plan.directories.map((entry) => entry.path) : []),
+  ];
+  if (entries.length === 0) {
+    return "printf '' ; exit 0";
+  }
+  const quotedEntries = entries.map((rel) => shellQuote(rel)).join(' ');
+  return [
+    'set -e',
+    'CFG="$HOME/.config/opencode"',
+    `cd "$CFG" && tar -h -czf - ${quotedEntries}`,
+  ].join('\n');
+};
+
+export const buildRemoteAgentsTarScript = () => [
+  'set -e',
+  'cd "$HOME" && tar -h -czf - .agents',
+].join('\n');
+
+export const buildRemoteAuthTarScript = () => [
+  'set -e',
+  'cd "$HOME/.local/share/opencode" && tar -h -czf - auth.json',
+].join('\n');
+
+export { shellQuote };

package/server/lib/config-sync/selections.js

@@ -0,0 +1,112 @@
+import { OPENCODE_CONFIG_SYNC_ALLOWLIST } from './constants.js';
+
+/**
+ * @typedef {{
+ *   fileGroups: boolean[],
+ *   singleFiles: boolean[],
+ *   directories: boolean[],
+ *   agentsRoot: boolean,
+ *   authFile: boolean,
+ * }} SyncSelections
+ */
+
+/**
+ * Default: everything selected except authFile (credentials stay opt-in).
+ * @param {{ includeAuthFile?: boolean }} [options]
+ * @returns {SyncSelections}
+ */
+export const buildDefaultSyncSelections = (options = {}) => ({
+  fileGroups: OPENCODE_CONFIG_SYNC_ALLOWLIST.fileGroups.map(() => true),
+  singleFiles: OPENCODE_CONFIG_SYNC_ALLOWLIST.singleFiles.map(() => true),
+  directories: OPENCODE_CONFIG_SYNC_ALLOWLIST.directories.map(() => true),
+  agentsRoot: true,
+  authFile: options.includeAuthFile === true,
+});
+
+/**
+ * Normalize a partial selections object against the allowlist shape.
+ * @param {Partial<SyncSelections> | null | undefined} raw
+ * @param {{ includeAuthFile?: boolean }} [options]
+ * @returns {SyncSelections}
+ */
+export const normalizeSyncSelections = (raw, options = {}) => {
+  const defaults = buildDefaultSyncSelections(options);
+  if (!raw || typeof raw !== 'object') return defaults;
+
+  const fileGroups = OPENCODE_CONFIG_SYNC_ALLOWLIST.fileGroups.map((_, index) => (
+    Array.isArray(raw.fileGroups) ? raw.fileGroups[index] !== false : defaults.fileGroups[index]
+  ));
+  const singleFiles = OPENCODE_CONFIG_SYNC_ALLOWLIST.singleFiles.map((_, index) => (
+    Array.isArray(raw.singleFiles) ? raw.singleFiles[index] !== false : defaults.singleFiles[index]
+  ));
+  const directories = OPENCODE_CONFIG_SYNC_ALLOWLIST.directories.map((_, index) => (
+    Array.isArray(raw.directories) ? raw.directories[index] !== false : defaults.directories[index]
+  ));
+
+  return {
+    fileGroups,
+    singleFiles,
+    directories,
+    agentsRoot: raw.agentsRoot !== false,
+    authFile: raw.authFile === true,
+  };
+};
+
+/**
+ * Filter a full plan down to the selected allowlist groups.
+ * Mutual-exclusion within a fileGroup is preserved (plan already picked a winner).
+ * @param {object} plan
+ * @param {SyncSelections} selections
+ */
+export const filterPlanBySelections = (plan, selections) => {
+  const selected = normalizeSyncSelections(selections, { includeAuthFile: selections?.authFile === true });
+  const selectedFileNames = new Set();
+  const selectedDeleteNames = new Set();
+
+  OPENCODE_CONFIG_SYNC_ALLOWLIST.fileGroups.forEach((group, index) => {
+    if (!selected.fileGroups[index]) return;
+    for (const name of group) {
+      selectedFileNames.add(name);
+      selectedDeleteNames.add(name);
+    }
+  });
+  OPENCODE_CONFIG_SYNC_ALLOWLIST.singleFiles.forEach((name, index) => {
+    if (!selected.singleFiles[index]) return;
+    selectedFileNames.add(name);
+  });
+
+  const selectedDirNames = new Set();
+  const selectedDirLegacy = new Set();
+  OPENCODE_CONFIG_SYNC_ALLOWLIST.directories.forEach((dirSpec, index) => {
+    if (!selected.directories[index]) return;
+    selectedDirNames.add(dirSpec.path);
+    selectedDeleteNames.add(dirSpec.path);
+    if (typeof dirSpec.legacy === 'string' && dirSpec.legacy) {
+      selectedDirLegacy.add(dirSpec.legacy);
+      selectedDeleteNames.add(dirSpec.legacy);
+    }
+  });
+
+  const files = (Array.isArray(plan?.files) ? plan.files : []).filter((entry) => selectedFileNames.has(entry.path));
+  const directories = (Array.isArray(plan?.directories) ? plan.directories : []).filter((entry) => selectedDirNames.has(entry.path));
+  const deletes = (Array.isArray(plan?.deletes) ? plan.deletes : []).filter((name) => selectedDeleteNames.has(name) || selectedDirLegacy.has(name));
+  const agentsRoot = selected.agentsRoot ? (plan?.agentsRoot ?? null) : null;
+  const authFile = selected.authFile ? (plan?.authFile ?? null) : null;
+
+  let totalBytes = 0;
+  for (const entry of files) totalBytes += Number(entry.bytes) || 0;
+  for (const entry of directories) totalBytes += Number(entry.bytes) || 0;
+  if (agentsRoot) totalBytes += Number(agentsRoot.bytes) || 0;
+  if (authFile) totalBytes += Number(authFile.bytes) || 0;
+
+  return {
+    ...plan,
+    files,
+    directories,
+    deletes,
+    agentsRoot,
+    authFile,
+    totalBytes,
+    selections: selected,
+  };
+};

package/server/lib/config-sync/tar.js

@@ -0,0 +1,36 @@
+import { spawn } from 'node:child_process';
+
+/**
+ * Collect stdout from a local `tar …` into a Buffer.
+ *
+ * Current callers buffer the entire archive in memory (SSH stdin putTar).
+ * The TargetExecutor.putTar contract accepts Buffer | AsyncIterable | Readable
+ * so a later relay transport can stream without changing the executor signature.
+ *
+ * @param {string[]} tarArgs
+ * @param {{ windowsHide?: boolean }} [spawnOptions]
+ * @returns {Promise<Buffer>}
+ */
+export const collectLocalTarBuffer = (tarArgs, spawnOptions = {}) => new Promise((resolve, reject) => {
+  const child = spawn('tar', tarArgs, {
+    stdio: ['ignore', 'pipe', 'pipe'],
+    ...(spawnOptions.windowsHide ? { windowsHide: true } : {}),
+  });
+  /** @type {Buffer[]} */
+  const chunks = [];
+  let stderr = '';
+  child.stdout?.on('data', (chunk) => {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  });
+  child.stderr?.on('data', (chunk) => {
+    stderr += chunk.toString();
+  });
+  child.on('error', reject);
+  child.on('close', (code) => {
+    if (code !== 0) {
+      reject(new Error((stderr || 'Local tar failed').trim()));
+      return;
+    }
+    resolve(Buffer.concat(chunks));
+  });
+});

package/server/lib/config-sync/target-id.js

@@ -0,0 +1,20 @@
+/** @param {string} instanceId */
+export const syncTargetIdForSshInstance = (instanceId) => {
+  const id = String(instanceId || '').trim();
+  if (!id) throw new Error('SSH instance id is required');
+  return `ssh:${id}`;
+};
+
+/** @param {string} hostId */
+export const syncTargetIdForDirectHost = (hostId) => {
+  const id = String(hostId || '').trim();
+  if (!id) throw new Error('Desktop host id is required');
+  return `host:${id}`;
+};
+
+/** @param {string} serverId relay host signing-key fingerprint */
+export const syncTargetIdForRelayServer = (serverId) => {
+  const id = String(serverId || '').trim();
+  if (!id) throw new Error('Relay serverId is required');
+  return `relay:${id}`;
+};

package/server/lib/git/DOCUMENTATION.md

@@ -111,7 +111,8 @@ The following functions are internal helpers used by exported functions:
 - `upstreamComparison`: Optional comparison against `upstream/<current-branch>`, with `{ remote, branch, ahead, behind }`.
 - `files`: Array of file objects with `path`, `index`, `working_dir` status codes.
 - `isClean`: Boolean indicating if working tree is clean.
-- `diffStats`: Object mapping file paths to `{ insertions, deletions }`.
+- `oversized`: Boolean. `true` when the change set exceeds the server-owned `GIT_STATUS_DIFF_STATS_MAX_FILES` threshold; `diffStats` are omitted in that case (same omission shape as light mode). Clients must derive deferred / load-on-demand rendering from this flag rather than from their own threshold, so the server can tune the limit without client changes. Light-mode polls do not set this flag.
+- `diffStats`: Object mapping file paths to `{ insertions, deletions }`. Omitted by light mode and by oversized change sets.
 - `mergeInProgress`: Object with `{ head, message }` if merge in progress.
 - `rebaseInProgress`: Object with `{ headName, onto }` if rebase in progress.
 

package/server/lib/git/service.js

@@ -1964,6 +1964,15 @@ export async function setLocalIdentity(directory, profile) {
   }
 }
 
+// Change sets larger than this are reported as `oversized` in the getStatus
+// response and omit diffStats (the same omission shape as light mode). Two
+// full-tree `git diff --numstat` passes and per-new-file line counting over an
+// oversized working tree block the server event loop for seconds; regular
+// repositories never reach this threshold. Clients must derive deferred /
+// load-on-demand behavior from the `oversized` flag, never from their own copy
+// of this threshold.
+const GIT_STATUS_DIFF_STATS_MAX_FILES = 2000;
+
 export async function getStatus(directory, options = {}) {
   const lightMode = options.mode === 'light';
 
@@ -1973,8 +1982,17 @@ export async function getStatus(directory, options = {}) {
     // Use -uall to show all untracked files individually, not just directories
     const status = await git.status(['-uall']);
 
+    // Oversized change sets: skip numstat + new-file stats the same way light
+    // mode does. Two full-tree `git diff --numstat` passes over a huge working
+    // tree take seconds and block the server event loop; regular repositories
+    // stay below the threshold and keep full diffStats. The `oversized` flag in
+    // the response tells clients to defer list rendering; light mode is a
+    // client-requested lightweight poll and does not set the flag.
+    const oversized = (status.files?.length ?? 0) > GIT_STATUS_DIFF_STATS_MAX_FILES;
+    const skipDiffStats = lightMode || oversized;
+
     // Light mode: skip numstat + new-file line counting for faster response
-    const [stagedStatsRaw, workingStatsRaw] = lightMode
+    const [stagedStatsRaw, workingStatsRaw] = skipDiffStats
       ? ['', '']
       : await Promise.all([
           git.raw(['diff', '--cached', '--numstat']).catch(() => ''),
@@ -2019,7 +2037,7 @@ export async function getStatus(directory, options = {}) {
     const MAX_NEW_FILE_STAT_SIZE = 1024 * 1024;
     const newFileStats = [];
 
-    if (!lightMode) {
+    if (!skipDiffStats) {
       for (const file of status.files) {
         if (newFileStats.length >= MAX_NEW_FILE_STATS) {
           break;
@@ -2126,7 +2144,7 @@ export async function getStatus(directory, options = {}) {
     // When no upstream is configured (common for new worktree branches), Git doesn't report ahead/behind.
     // We still want to show the number of unpublished commits to the user.
     // Light mode skips this — the basic ahead/behind from git status is sufficient for polling.
-    if (!lightMode && !tracking && status.current) {
+    if (!skipDiffStats && !tracking && status.current) {
       const baseRef = await selectBaseRefForUnpublished();
       if (baseRef) {
         const countRaw = await git
@@ -2142,7 +2160,7 @@ export async function getStatus(directory, options = {}) {
     }
 
     if (
-      !lightMode
+      !skipDiffStats
       && status.current
       && (!tracking || !tracking.startsWith('upstream/'))
       && await hasRemote(git, directoryPath, 'upstream')
@@ -2217,7 +2235,8 @@ export async function getStatus(directory, options = {}) {
         working_dir: f.working_dir,
       })),
       isClean: status.isClean(),
-      diffStats: lightMode ? undefined : diffStats,
+      oversized,
+      diffStats: skipDiffStats ? undefined : diffStats,
       mergeInProgress,
       rebaseInProgress,
     };

package/server/lib/git/service.test.js

@@ -282,6 +282,57 @@ describe('getStatus', () => {
 
     await expect(getStatus(repo)).resolves.toMatchObject({ current: 'main' });
   });
+
+  it('returns diffStats for regular-sized change sets', async () => {
+    if (!canRunGit()) return;
+
+    const repo = createTempDir();
+    runGit(repo, ['init', '-b', 'main']);
+    runGit(repo, ['config', 'user.email', 'test@example.com']);
+    runGit(repo, ['config', 'user.name', 'Test User']);
+    fs.writeFileSync(path.join(repo, 'README.md'), '# Test\n');
+    runGit(repo, ['add', 'README.md']);
+    runGit(repo, ['commit', '-m', 'Initial commit']);
+    fs.writeFileSync(path.join(repo, 'README.md'), '# Test\nMore lines\n');
+
+    const status = await getStatus(repo);
+    expect(status.oversized).toBe(false);
+    expect(status.diffStats).toBeDefined();
+    expect(status.diffStats['README.md']).toEqual({ insertions: 1, deletions: 0 });
+  });
+
+  it('marks oversized change sets and omits diffStats without changing the rest of the contract', async () => {
+    if (!canRunGit()) return;
+
+    const repo = createTempDir();
+    runGit(repo, ['init', '-b', 'main']);
+    runGit(repo, ['config', 'user.email', 'test@example.com']);
+    runGit(repo, ['config', 'user.name', 'Test User']);
+    fs.writeFileSync(path.join(repo, 'README.md'), '# Test\n');
+    runGit(repo, ['add', 'README.md']);
+    runGit(repo, ['commit', '-m', 'Initial commit']);
+
+    // Create one modified tracked file plus enough untracked files to cross
+    // the oversized threshold (untracked files are part of status.files).
+    fs.writeFileSync(path.join(repo, 'README.md'), '# Test\nChanged\n');
+    const oversizeCount = 2001;
+    fs.mkdirSync(path.join(repo, 'generated'), { recursive: true });
+    for (let i = 0; i < oversizeCount; i += 1) {
+      fs.writeFileSync(path.join(repo, 'generated', `file-${i}.txt`), `content ${i}\n`);
+    }
+
+    const status = await getStatus(repo);
+    expect(status.files.length).toBeGreaterThan(2000);
+    // The server flags the oversized state so clients defer list rendering.
+    expect(status.oversized).toBe(true);
+    // Same omission shape as light mode: the key is absent, not an empty object.
+    expect(status.diffStats).toBeUndefined();
+    // Everything else in the contract stays intact.
+    expect(status.current).toBe('main');
+    expect(status.isClean).toBe(false);
+    expect(status.files.some((file) => file.path === 'README.md')).toBe(true);
+    expect(status.files.some((file) => file.path.startsWith('generated/'))).toBe(true);
+  });
 });
 
 // ---------------------------------------------------------------------------

package/server/lib/opencode/DOCUMENTATION.md

@@ -184,13 +184,16 @@ This module provides OpenCode server integration utilities for the web server ru
 
 ## Public exports (settings-runtime.js)
 - `createSettingsRuntime(dependencies)`: creates settings lifecycle runtime for read/migrate/persist concerns.
+- Optional dependency `runExclusivePersist` / `getRunExclusivePersist`, plus returned `setRunExclusivePersist(fn)`, let an in-process host (Electron) replace the default `persistSettingsLock` with a shared exclusive runner so desktop main/ssh writers and web settings persistence serialize on one chain.
 - Returned API:
   - `readSettingsFromDisk()`
   - `readSettingsFromDiskMigrated()`
   - `writeSettingsToDisk(settings)`
   - `persistSettings(changes)`
+  - `setRunExclusivePersist(fn)`
   - Persistent permission auto-accept policy is stored under `permissionAutoAccept`; execution ownership lives in `lib/permission-auto-accept/`.
   - One-shot compact-chat defaults migration: when disk marker `compactChatDefaultsMigrationVersion` is missing, rewrite legacy/absent `chatRenderMode`/`activityRenderMode`/`showTurnChangedFiles` to `sorted`/`collapsed`/`true` and persist marker `1` (marker stays on disk; response allowlist still hides it). Marker already `1` preserves user values; `persistSettings` runs the same migration before the first write.
+  - `startWebUiServer({ settingsPersistLock })` late-binds that shared runner after module load.
 
 ## Public exports (settings-helpers.js)
 - `createSettingsHelpers(dependencies)`: creates settings helper runtime for settings request/response shaping.

package/server/lib/opencode/bootstrap-runtime.js

@@ -30,6 +30,7 @@ export const createBootstrapRuntime = (dependencies) => {
       getServerId,
       getServerLabel,
       readSettingsFromDiskMigrated,
+      persistSettings,
       normalizeTunnelSessionTtlMs,
       authorizeManagedOpenCodeBridgeRequest,
       sayTTSCapability,
@@ -147,6 +148,7 @@ export const createBootstrapRuntime = (dependencies) => {
       __dirname,
       openchamberDataDir,
       readSettingsFromDiskMigrated,
+      persistSettings,
       fetchFreeZenModels,
       getCachedZenModels,
       sessionIndexService,

package/server/lib/opencode/core-routes.js

@@ -1127,6 +1127,7 @@ export const registerCommonRequestMiddleware = (app, dependencies) => {
     } else if (
       (req.method === 'PUT' && req.path.match(/^\/api\/openchamber\/message-queue\/attachments\/uploads\/[^/]+\/?$/))
       || (req.method === 'PUT' && req.path.match(/^\/api\/fs\/prompt-attachments\/[^/]+\/?$/))
+      || (req.method === 'PUT' && req.path.match(/^\/api\/openchamber\/config-sync\/put\/[^/]+\/?$/))
     ) {
       // Binary attachment uploads stream as the request body. Parsing JSON here
       // would buffer the entire payload and block the relay tunnel.

package/server/lib/opencode/openchamber-routes.js

@@ -1,6 +1,7 @@
 import { registerSessionIndexRoutes } from '../session-index/routes.js';
 import { registerTranscriptCacheRoutes } from '../transcript-cache/routes.js';
 import { registerDesktopHostRoutes } from '../desktop-hosts/routes.js';
+import { registerConfigSyncRoutes } from '../config-sync/routes.js';
 
 export const registerOpenChamberRoutes = (app, dependencies) => {
   const {
@@ -11,6 +12,7 @@ export const registerOpenChamberRoutes = (app, dependencies) => {
     __dirname,
     openchamberDataDir,
     readSettingsFromDiskMigrated,
+    persistSettings,
     fetchFreeZenModels,
     getCachedZenModels,
     sessionIndexService,
@@ -31,6 +33,11 @@ export const registerOpenChamberRoutes = (app, dependencies) => {
     getPairingSession,
     express,
   });
+  registerConfigSyncRoutes(app, {
+    readSettingsFromDiskMigrated,
+    persistSettings,
+    express,
+  });
 
   app.get('/api/openchamber/update-check', async (req, res) => {
     try {