@doubling/compound-sync 1.3.1 → 1.4.1

package/README.md

@@ -42,6 +42,22 @@ npx @doubling/compound-sync
 
 The sync daemon runs until you press Ctrl+C.
 
+## Multiple workspaces
+
+If you're a member of more than one workspace, you can sync them all from a single daemon. During `--setup` you'll be asked which workspaces to sync (comma-separated or `all`) and given a per-workspace local folder prompt.
+
+You can also keep multiple separate configs (one per workspace, or one for "all my workspaces") with `--config` pointing at an absolute path:
+
+```bash
+# Setup
+npx @doubling/compound-sync --config ~/.config/compound-sync/work.json --setup
+
+# Run
+npx @doubling/compound-sync --config ~/.config/compound-sync/work.json
+```
+
+`--config` accepts absolute paths (with `~` expanded), so you can keep configs outside the package install directory. Bare filenames still resolve relative to the package install for backward compatibility.
+
 ## Security
 
 - No credentials are stored on disk
@@ -66,6 +82,19 @@ npx @doubling/compound-sync --env dev --config config-dev.json
 
 Config files (`config-*.json`) are gitignored and stored locally.
 
+### Tests
+
+```bash
+# Pure unit tests (no emulator required)
+npm run test:unit
+
+# Integration tests (boots firestore + storage emulators)
+npm run test:integration
+
+# Both
+npm test
+```
+
 ### Publishing to npm
 
 After making changes to the sync daemon, publish a new version:

package/config.js

@@ -0,0 +1,103 @@
+// Config loading + normalization for the sync daemon.
+//
+// Two schemas are supported on disk:
+//
+//   Legacy (single org):
+//     {
+//       "projectId": "doubling-compound-prod",
+//       "orgId": "abc123",
+//       "localPath": "/Users/me/Compound"
+//     }
+//
+//   Multi-org:
+//     {
+//       "projectId": "doubling-compound-prod",
+//       "orgs": [
+//         { "orgId": "abc123", "localPath": "/Users/me/Doubling" },
+//         { "orgId": "def456", "localPath": "/Users/me/Hoom" }
+//       ]
+//     }
+//
+// `normalizeConfig` produces the multi-org shape from either.
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+function expandHome(p) {
+  if (typeof p !== 'string') return p;
+  if (p === '~') return os.homedir();
+  if (p.startsWith('~/')) return path.join(os.homedir(), p.slice(2));
+  return p;
+}
+
+// Resolve a --config arg to an absolute path.
+// Absolute paths are returned as-is. ~/ is expanded to the user home.
+// Otherwise the arg is treated as relative to defaultDir.
+export function resolveConfigPath(arg, defaultDir) {
+  const expanded = expandHome(arg);
+  if (path.isAbsolute(expanded)) return expanded;
+  return path.join(defaultDir, expanded);
+}
+
+// Normalize a raw config object into the multi-org shape.
+// Throws if required fields are missing or contradictory.
+export function normalizeConfig(raw) {
+  if (!raw || typeof raw !== 'object') {
+    throw new Error('Config must be an object');
+  }
+  if (!raw.projectId) {
+    throw new Error('Config is missing required field: projectId');
+  }
+
+  let orgs;
+  if (Array.isArray(raw.orgs)) {
+    orgs = raw.orgs;
+  } else if (raw.orgId) {
+    orgs = [{ orgId: raw.orgId, localPath: raw.localPath }];
+  } else {
+    throw new Error('Config must define either orgs[] or orgId');
+  }
+
+  if (orgs.length === 0) {
+    throw new Error('Config must define at least one org');
+  }
+
+  const seenPaths = new Set();
+  const normalizedOrgs = orgs.map((entry, idx) => {
+    if (!entry || typeof entry !== 'object') {
+      throw new Error(`orgs[${idx}] must be an object`);
+    }
+    if (!entry.orgId) {
+      throw new Error(`orgs[${idx}] is missing required field: orgId`);
+    }
+    if (!entry.localPath) {
+      throw new Error(`orgs[${idx}] is missing required field: localPath`);
+    }
+    const localPath = expandHome(entry.localPath);
+    if (seenPaths.has(localPath)) {
+      throw new Error(`orgs[${idx}] has a duplicate localPath: ${localPath}`);
+    }
+    seenPaths.add(localPath);
+    return { orgId: entry.orgId, localPath };
+  });
+
+  return { projectId: raw.projectId, orgs: normalizedOrgs };
+}
+
+// Load a config file from disk and return it normalized.
+// Returns null if the file doesn't exist (caller can trigger setup).
+// Throws if the file exists but is invalid JSON or fails normalization.
+export function loadConfig(absPath) {
+  if (!fs.existsSync(absPath)) return null;
+  const raw = JSON.parse(fs.readFileSync(absPath, 'utf-8'));
+  return normalizeConfig(raw);
+}
+
+// Write a config object to disk. Creates the parent directory chain if
+// it doesn't already exist (so callers can target paths like
+// ~/.config/compound-sync/work.json without manual mkdir).
+export function saveConfig(absPath, configObject) {
+  fs.mkdirSync(path.dirname(absPath), { recursive: true });
+  fs.writeFileSync(absPath, JSON.stringify(configObject, null, 2) + '\n');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@doubling/compound-sync",
-  "version": "1.3.1",
+  "version": "1.4.1",
   "description": "Bidirectional sync between Compound and local markdown files",
   "type": "module",
   "bin": {
@@ -8,16 +8,20 @@
   },
   "files": [
     "sync.js",
+    "config.js",
+    "paths.js",
     "dual-write.js",
     "README.md"
   ],
   "scripts": {
     "sync": "node sync.js",
-    "test": "firebase emulators:exec --only firestore,storage 'node --test dual-write.test.js'"
+    "test:unit": "node --test config.test.js paths.test.js",
+    "test:integration": "firebase emulators:exec --only firestore,storage 'node --test dual-write.test.js'",
+    "test": "npm run test:unit && npm run test:integration"
   },
   "dependencies": {
     "firebase": "^11.7.0",
-    "chokidar": "^4.0.0"
+    "chokidar": "^5.0.0"
   },
   "devDependencies": {
     "@firebase/rules-unit-testing": "^4.0.0",

package/paths.js

@@ -0,0 +1,52 @@
+// Pure path/scope helpers. No fs, no Firebase, no module-level state.
+//
+// The "scope" vocabulary used here (team / private / shared-with-me /
+// shared-by-me) reflects the current Firestore data model and is
+// expected to be swapped if/when authorization moves to a Zanzibar-
+// style relationship model. Keep this module's interface narrow so the
+// swap stays localized.
+
+import path from 'node:path';
+
+export const PRIVATE_FOLDER = 'Private';
+export const SHARED_WITH_ME_FOLDER = 'Shared with Me';
+export const SHARED_BY_ME_FOLDER = 'Shared by Me';
+const TEAMSPACE_SUFFIX = ' Teamspace';
+
+export function teamFolderName(teamName) {
+  return teamName + TEAMSPACE_SUFFIX;
+}
+
+// Given an absolute file path within one of the daemon's local sync
+// roots, return { scope, teamId?, docPath }. The caller passes the
+// matching localPath root and the team-name → team-id map.
+export function scopeFromLocalPath(filePath, localPath, teamIdsByName) {
+  const rel = path.relative(localPath, filePath);
+
+  if (rel.startsWith(PRIVATE_FOLDER + path.sep)) {
+    return {
+      scope: 'private',
+      docPath: rel.slice(PRIVATE_FOLDER.length + 1),
+    };
+  }
+  if (rel.startsWith(SHARED_WITH_ME_FOLDER + path.sep)) {
+    return {
+      scope: 'shared-with-me',
+      docPath: rel.slice(SHARED_WITH_ME_FOLDER.length + 1),
+    };
+  }
+  if (rel.startsWith(SHARED_BY_ME_FOLDER + path.sep)) {
+    return {
+      scope: 'shared-by-me',
+      docPath: rel.slice(SHARED_BY_ME_FOLDER.length + 1),
+    };
+  }
+
+  const parts = rel.split(path.sep);
+  const folderName = parts[0];
+  const teamName = folderName.endsWith(TEAMSPACE_SUFFIX)
+    ? folderName.slice(0, -TEAMSPACE_SUFFIX.length)
+    : folderName;
+  const teamId = teamIdsByName.get(teamName);
+  return { scope: 'team', teamId, docPath: parts.slice(1).join('/') };
+}

package/sync.js

@@ -33,6 +33,14 @@ import http from 'http';
 import { exec } from 'child_process';
 import { fileURLToPath } from 'url';
 import { pushFileToCloud, deleteFileFromCloud, readFileContent } from './dual-write.js';
+import { resolveConfigPath, loadConfig, saveConfig } from './config.js';
+import {
+  scopeFromLocalPath,
+  teamFolderName,
+  PRIVATE_FOLDER,
+  SHARED_WITH_ME_FOLDER,
+  SHARED_BY_ME_FOLDER,
+} from './paths.js';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
@@ -301,56 +309,66 @@ async function setupConfig() {
   });
   console.log('');
 
-  let orgId;
+  let selectedIndices;
   if (orgs.length === 1) {
     const confirm = await ask(`Use "${orgs[0].name}"? [Y/n]: `) || 'y';
-    if (confirm.toLowerCase() === 'y') {
-      orgId = orgs[0].id;
-    } else {
-      process.exit(0);
-    }
+    if (confirm.toLowerCase() !== 'y') process.exit(0);
+    selectedIndices = [0];
   } else {
-    const choice = await ask(`Select organization [1-${orgs.length}]: `);
-    const idx = parseInt(choice) - 1;
-    if (idx < 0 || idx >= orgs.length) {
-      console.error('Invalid selection.');
-      process.exit(1);
+    const choice = await ask(
+      `Select organizations to sync (e.g. "1,3" or "all") [1-${orgs.length}]: `,
+    );
+    if (choice.toLowerCase() === 'all') {
+      selectedIndices = orgs.map((_, i) => i);
+    } else {
+      selectedIndices = choice
+        .split(',')
+        .map(s => parseInt(s.trim(), 10) - 1)
+        .filter(i => Number.isInteger(i) && i >= 0 && i < orgs.length);
+      if (selectedIndices.length === 0) {
+        console.error('Invalid selection.');
+        process.exit(1);
+      }
     }
-    orgId = orgs[idx].id;
   }
 
-  // Local path
-  console.log('');
-  const orgName = orgs.find(o => o.id === orgId).name;
-  const defaultPath = path.join(os.homedir(), orgName + ' Workspace');
-  const localPath = await ask(`Local sync folder [${defaultPath}]: `) || defaultPath;
-  const resolvedPath = expandHome(localPath);
-
-  if (!fs.existsSync(resolvedPath)) {
-    const create = await ask(`"${resolvedPath}" doesn't exist. Create it? [Y/n]: `) || 'y';
-    if (create.toLowerCase() === 'y') {
-      fs.mkdirSync(resolvedPath, { recursive: true });
-      console.log('Created.');
-    } else {
-      process.exit(0);
+  // Per-org local path
+  const orgEntries = [];
+  for (const idx of selectedIndices) {
+    const org = orgs[idx];
+    console.log('');
+    const defaultPath = path.join(os.homedir(), org.name + ' Workspace');
+    const localPath = await ask(
+      `Local sync folder for "${org.name}" [${defaultPath}]: `,
+    ) || defaultPath;
+    const resolvedPath = expandHome(localPath);
+
+    if (!fs.existsSync(resolvedPath)) {
+      const create = await ask(`"${resolvedPath}" doesn't exist. Create it? [Y/n]: `) || 'y';
+      if (create.toLowerCase() === 'y') {
+        fs.mkdirSync(resolvedPath, { recursive: true });
+        console.log('Created.');
+      } else {
+        process.exit(0);
+      }
     }
+    orgEntries.push({ orgId: org.id, localPath: resolvedPath });
   }
 
-  // Save config (no credentials stored)
-  const savedConfig = {
+  // Save config (no credentials stored). saveConfig creates parent dirs
+  // so paths like ~/.config/compound-sync/work.json work without manual mkdir.
+  saveConfig(CONFIG_PATH, { projectId, orgs: orgEntries });
+  console.log('');
+  console.log(`Config saved to ${CONFIG_PATH}`);
+  console.log('');
+
+  return {
     projectId,
-    orgId,
-    localPath: resolvedPath,
+    orgs: orgEntries,
     _userId: userId,
     _app: app,
     _db: db,
   };
-  fs.writeFileSync(CONFIG_PATH, JSON.stringify({ projectId, orgId, localPath: resolvedPath }, null, 2) + '\n');
-  console.log('');
-  console.log(`Config saved to ${CONFIG_PATH}`);
-  console.log('');
-
-  return savedConfig;
 }
 
 // --- App Check (custom provider for CLI) ---
@@ -455,15 +473,19 @@ for (let i = 0; i < args.length; i++) {
   if (args[i] === '--env' && args[i + 1]) { envOverride = `doubling-compound-${args[++i]}`; }
 }
 
-const CONFIG_PATH = path.join(__dirname, configFile);
-let config = {};
-if (!forceSetup && fs.existsSync(CONFIG_PATH)) {
-  config = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf-8'));
+const CONFIG_PATH = resolveConfigPath(configFile, __dirname);
+let config = null;
+if (!forceSetup) {
+  try {
+    config = loadConfig(CONFIG_PATH);
+  } catch (err) {
+    console.error(`Failed to load ${CONFIG_PATH}: ${err.message}`);
+    process.exit(1);
+  }
 }
-if (forceSetup) { config = {}; }
 
-// Interactive setup if no config
-if (!config.projectId || !config.orgId) {
+// Interactive setup if no config exists or --setup was passed
+if (!config) {
   config = await setupConfig();
 }
 
@@ -518,327 +540,285 @@ if (config._app) {
 
 }
 
-const ORG_ID = config.orgId;
 const USER_ID = userId;
-const LOCAL_PATH = expandHome(config.localPath || path.join(os.homedir(), 'Sync'));
-
-const filesRef = collection(db, `orgs/${ORG_ID}/files`);
-
-// --- Cloud Storage handle ---
-//
-// Dual-write file content to Cloud Storage in addition to the Firestore
-// `content` field. Implementation lives in ./dual-write.js so it can be
-// imported by tests and other callers without triggering the daemon's
-// browser-auth side effects.
-
 const storage = getStorage(app);
 
-// --- Load teams ---
-
-const teams = new Map();
-const teamIdsByName = new Map();
-
-async function loadTeams() {
-  const snapshot = await getDocs(collection(db, `orgs/${ORG_ID}/teams`));
-  snapshot.forEach(doc => {
-    const data = doc.data();
-    teams.set(doc.id, data);
-    teamIdsByName.set(data.name, doc.id);
-  });
-}
-
-await loadTeams();
-
 console.log(`Sync daemon starting...`);
 console.log(`  Env:      ${config.projectId}`);
-console.log(`  Org:      ${ORG_ID}`);
 console.log(`  User:     ${USER_ID}`);
-console.log(`  Local:    ${LOCAL_PATH}`);
-console.log(`  Teams:    ${[...teams.values()].map(t => t.name).join(', ') || 'none'}`);
+console.log(`  Orgs:     ${config.orgs.length}`);
+
+// Per-org runtime: each org gets its own closure with isolated state
+// (LOCAL_PATH, filesRef, teams map, debounce sets, watcher, listeners).
+// This keeps two orgs' sync logic from interfering with each other.
+async function setupOrgSync({ orgId, localPath: rawLocalPath }) {
+  const LOCAL_PATH = expandHome(rawLocalPath);
+  const filesRef = collection(db, `orgs/${orgId}/files`);
+
+  const teams = new Map();
+  const teamIdsByName = new Map();
+  const lastKnownUpdate = new Map();
+  const suppressLocal = new Set();
+
+  async function loadTeams() {
+    const snapshot = await getDocs(collection(db, `orgs/${orgId}/teams`));
+    snapshot.forEach(d => {
+      const data = d.data();
+      teams.set(d.id, data);
+      teamIdsByName.set(data.name, d.id);
+    });
+  }
 
-// --- Scope-aware path helpers ---
+  await loadTeams();
 
-const PRIVATE_FOLDER = 'Private';
-const SHARED_WITH_ME_FOLDER = 'Shared with Me';
-const SHARED_BY_ME_FOLDER = 'Shared by Me';
+  console.log('');
+  console.log(`  [${orgId}] Local: ${LOCAL_PATH}`);
+  console.log(`  [${orgId}] Teams: ${[...teams.values()].map(t => t.name).join(', ') || 'none'}`);
 
-const lastKnownUpdate = new Map();
-const suppressLocal = new Set();
+  function ensureDir(filePath) {
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  }
 
-function updateSharedByMeSymlink(fileDoc, realPath) {
-  const sharedWith = fileDoc.sharedWith || [];
-  const symlinkPath = path.join(LOCAL_PATH, SHARED_BY_ME_FOLDER, fileDoc.path);
+  function updateSharedByMeSymlink(fileDoc, realPath) {
+    const sharedWith = fileDoc.sharedWith || [];
+    const symlinkPath = path.join(LOCAL_PATH, SHARED_BY_ME_FOLDER, fileDoc.path);
 
-  if (sharedWith.length > 0) {
-    ensureDir(symlinkPath);
-    const relativeTo = path.relative(path.dirname(symlinkPath), realPath);
-    try {
-      if (fs.existsSync(symlinkPath) || fs.lstatSync(symlinkPath).isSymbolicLink()) {
-        fs.unlinkSync(symlinkPath);
+    if (sharedWith.length > 0) {
+      ensureDir(symlinkPath);
+      const relativeTo = path.relative(path.dirname(symlinkPath), realPath);
+      try {
+        if (fs.existsSync(symlinkPath) || fs.lstatSync(symlinkPath).isSymbolicLink()) {
+          fs.unlinkSync(symlinkPath);
+        }
+      } catch (e) { /* doesn't exist */ }
+      try {
+        fs.symlinkSync(relativeTo, symlinkPath);
+        console.log(`  [${orgId}] [symlink] ${fileDoc.path} → Shared by Me/`);
+      } catch (e) {
+        if (e.code !== 'EEXIST') console.error(`  [${orgId}] Symlink error: ${e.message}`);
       }
-    } catch (e) { /* doesn't exist */ }
-    try {
-      fs.symlinkSync(relativeTo, symlinkPath);
-      console.log(`  [symlink] ${fileDoc.path} → Shared by Me/`);
-    } catch (e) {
-      if (e.code !== 'EEXIST') console.error(`  Symlink error: ${e.message}`);
+    } else {
+      try {
+        if (fs.lstatSync(symlinkPath).isSymbolicLink()) {
+          fs.unlinkSync(symlinkPath);
+          console.log(`  [${orgId}] [symlink] removed Shared by Me/${fileDoc.path}`);
+        }
+      } catch (e) { /* doesn't exist */ }
     }
-  } else {
-    try {
-      if (fs.lstatSync(symlinkPath).isSymbolicLink()) {
-        fs.unlinkSync(symlinkPath);
-        console.log(`  [symlink] removed Shared by Me/${fileDoc.path}`);
-      }
-    } catch (e) { /* doesn't exist */ }
   }
-}
 
-function scopeFromLocalPath(filePath) {
-  const rel = path.relative(LOCAL_PATH, filePath);
+  function ensureFolderStructure() {
+    const privatePath = path.join(LOCAL_PATH, PRIVATE_FOLDER);
+    if (!fs.existsSync(privatePath)) fs.mkdirSync(privatePath, { recursive: true });
 
-  if (rel.startsWith(PRIVATE_FOLDER + path.sep)) {
-    return { scope: 'private', docPath: rel.slice(PRIVATE_FOLDER.length + 1) };
-  }
-  if (rel.startsWith(SHARED_WITH_ME_FOLDER + path.sep)) {
-    return { scope: 'shared-with-me', docPath: rel.slice(SHARED_WITH_ME_FOLDER.length + 1) };
-  }
-  if (rel.startsWith(SHARED_BY_ME_FOLDER + path.sep)) {
-    return { scope: 'shared-by-me', docPath: rel.slice(SHARED_BY_ME_FOLDER.length + 1) };
-  }
-  const parts = rel.split(path.sep);
-  const folderName = parts[0];
-  const teamName = folderName.endsWith(' Teamspace') ? folderName.slice(0, -' Teamspace'.length) : folderName;
-  const teamId = teamIdsByName.get(teamName);
-  return { scope: 'team', teamId, docPath: parts.slice(1).join('/') };
-}
+    const sharedWithMePath = path.join(LOCAL_PATH, SHARED_WITH_ME_FOLDER);
+    if (!fs.existsSync(sharedWithMePath)) fs.mkdirSync(sharedWithMePath, { recursive: true });
+
+    const sharedByMePath = path.join(LOCAL_PATH, SHARED_BY_ME_FOLDER);
+    if (!fs.existsSync(sharedByMePath)) fs.mkdirSync(sharedByMePath, { recursive: true });
 
-function ensureDir(filePath) {
-  const dir = path.dirname(filePath);
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true });
+    for (const [, teamData] of teams) {
+      const teamPath = path.join(LOCAL_PATH, teamFolderName(teamData.name));
+      if (!fs.existsSync(teamPath)) fs.mkdirSync(teamPath, { recursive: true });
+    }
   }
-}
 
-// --- Create local folder structure ---
+  ensureFolderStructure();
 
-function ensureFolderStructure() {
-  const privatePath = path.join(LOCAL_PATH, PRIVATE_FOLDER);
-  if (!fs.existsSync(privatePath)) fs.mkdirSync(privatePath, { recursive: true });
+  async function handleFirestoreChange(change, getLocalPath) {
+    const data = change.doc.data();
+    const docPath = data.path;
+    if (!docPath) return;
 
-  const sharedWithMePath = path.join(LOCAL_PATH, SHARED_WITH_ME_FOLDER);
-  if (!fs.existsSync(sharedWithMePath)) fs.mkdirSync(sharedWithMePath, { recursive: true });
+    const localFilePath = getLocalPath(data);
+    const trackingKey = `${data.scope || 'team'}:${docPath}`;
 
-  const sharedByMePath = path.join(LOCAL_PATH, SHARED_BY_ME_FOLDER);
-  if (!fs.existsSync(sharedByMePath)) fs.mkdirSync(sharedByMePath, { recursive: true });
+    if (change.type === 'removed') {
+      if (fs.existsSync(localFilePath)) {
+        console.log(`  [${orgId}] [firestore → local] DELETE ${docPath}`);
+        suppressLocal.add(localFilePath);
+        fs.unlinkSync(localFilePath);
+        setTimeout(() => suppressLocal.delete(localFilePath), 1000);
+      }
+      lastKnownUpdate.delete(trackingKey);
+      return;
+    }
 
-  for (const [, teamData] of teams) {
-    const teamPath = path.join(LOCAL_PATH, teamData.name + ' Teamspace');
-    if (!fs.existsSync(teamPath)) fs.mkdirSync(teamPath, { recursive: true });
-  }
-}
+    const remoteUpdated = data.updatedAt || data.createdAt || '';
+    const lastKnown = lastKnownUpdate.get(trackingKey);
+    if (lastKnown && lastKnown >= remoteUpdated) return;
 
-ensureFolderStructure();
+    if (fs.existsSync(localFilePath)) {
+      const localMtime = fs.statSync(localFilePath).mtime.toISOString();
+      if (localMtime > remoteUpdated) return;
+    }
 
-// --- Firestore → Local (multiple listeners) ---
+    const action = change.type === 'added' ? 'CREATE' : 'UPDATE';
+    console.log(`  [${orgId}] [firestore → local] ${action} ${docPath} (${data.scope || 'team'})`);
+    ensureDir(localFilePath);
+    suppressLocal.add(localFilePath);
 
-async function handleFirestoreChange(change, getLocalPath) {
-  const data = change.doc.data();
-  const docPath = data.path;
-  if (!docPath) return;
+    const content = await readFileContent({
+      storage,
+      orgId,
+      fileId: change.doc.id,
+    });
+    fs.writeFileSync(localFilePath, content || '', 'utf-8');
+    lastKnownUpdate.set(trackingKey, remoteUpdated);
+    setTimeout(() => suppressLocal.delete(localFilePath), 1000);
+  }
 
-  const localPath = getLocalPath(data);
-  const trackingKey = `${data.scope || 'team'}:${docPath}`;
+  function startFirestoreListeners() {
+    console.log(`  [${orgId}] Starting Firestore listeners...`);
+
+    for (const [teamId, teamData] of teams) {
+      const teamFolder = teamFolderName(teamData.name);
+      const q = query(filesRef, where('scope', '==', 'team'), where('teamId', '==', teamId));
+      onSnapshot(q, snapshot => {
+        snapshot.docChanges().forEach(change => {
+          handleFirestoreChange(change, data =>
+            path.join(LOCAL_PATH, teamFolder, data.path),
+          ).catch(err => console.error(`  [${orgId}] Firestore change handler error:`, err && err.message));
+        });
+      }, err => console.error(`  [${orgId}] Team "${teamFolder}" listener error:`, err));
+      console.log(`  [${orgId}]   Listening: ${teamFolder}`);
+    }
 
-  if (change.type === 'removed') {
-    if (fs.existsSync(localPath)) {
-      console.log(`  [firestore → local] DELETE ${docPath}`);
-      suppressLocal.add(localPath);
-      fs.unlinkSync(localPath);
-      setTimeout(() => suppressLocal.delete(localPath), 1000);
+    if (USER_ID) {
+      const privateQ = query(filesRef, where('scope', '==', 'private'), where('ownerId', '==', USER_ID));
+      onSnapshot(privateQ, snapshot => {
+        snapshot.docChanges().forEach(change => {
+          const data = change.doc.data();
+          const realPath = path.join(LOCAL_PATH, PRIVATE_FOLDER, data.path);
+
+          handleFirestoreChange(change, () => realPath)
+            .catch(err => console.error(`  [${orgId}] Firestore change handler error:`, err && err.message));
+
+          if (change.type !== 'removed') {
+            updateSharedByMeSymlink(data, realPath);
+          } else {
+            const symlinkPath = path.join(LOCAL_PATH, SHARED_BY_ME_FOLDER, data.path);
+            try { fs.lstatSync(symlinkPath); fs.unlinkSync(symlinkPath); } catch (e) { /* ok */ }
+          }
+        });
+      }, err => console.error(`  [${orgId}] Private files listener error:`, err));
+      console.log(`  [${orgId}]   Listening: Private files + Shared by Me symlinks`);
+
+      const sharedQ = query(filesRef, where('sharedWith', 'array-contains', USER_ID));
+      onSnapshot(sharedQ, snapshot => {
+        snapshot.docChanges().forEach(change => {
+          const data = change.doc.data();
+          if (data.ownerId === USER_ID) return;
+          handleFirestoreChange(change, () =>
+            path.join(LOCAL_PATH, SHARED_WITH_ME_FOLDER, data.path),
+          ).catch(err => console.error(`  [${orgId}] Firestore change handler error:`, err && err.message));
+        });
+      }, err => console.error(`  [${orgId}] Shared with me listener error:`, err));
+      console.log(`  [${orgId}]   Listening: Shared with Me`);
     }
-    lastKnownUpdate.delete(trackingKey);
-    return;
   }
 
-  const remoteUpdated = data.updatedAt || data.createdAt || '';
-  const lastKnown = lastKnownUpdate.get(trackingKey);
-
-  if (lastKnown && lastKnown >= remoteUpdated) return;
+  async function pushToFirestore(filePath, content) {
+    const { scope, teamId, docPath } = scopeFromLocalPath(filePath, LOCAL_PATH, teamIdsByName);
+    const trackingKey = `${scope}:${docPath}`;
+    const now = new Date().toISOString();
+    lastKnownUpdate.set(trackingKey, now);
+
+    const result = await pushFileToCloud({
+      filesRef,
+      storage,
+      orgId,
+      userId: USER_ID,
+      scope,
+      teamId,
+      docPath,
+      content,
+      now,
+    });
 
-  if (fs.existsSync(localPath)) {
-    const localMtime = fs.statSync(localPath).mtime.toISOString();
-    if (localMtime > remoteUpdated) return;
+    if (result.action === 'created') {
+      console.log(`  [${orgId}] [local → firestore] CREATE ${docPath} (${scope})`);
+    } else if (result.action === 'updated') {
+      console.log(`  [${orgId}] [local → firestore] UPDATE ${docPath} (${scope})`);
+    }
+    if (result.storageError) {
+      console.error(`  [${orgId}] [storage] upload failed for ${docPath}: ${result.storageError.message}`);
+    }
   }
 
-  const action = change.type === 'added' ? 'CREATE' : 'UPDATE';
-  console.log(`  [firestore → local] ${action} ${docPath} (${data.scope || 'team'})`);
-  ensureDir(localPath);
-  suppressLocal.add(localPath);
-
-  // Read content from Cloud Storage. As of PR 6 there is no
-  // fallback; any read failure propagates to the caller's catch
-  // handler (handleFirestoreChange's promise rejection logger).
-  const content = await readFileContent({
-    storage,
-    orgId: ORG_ID,
-    fileId: change.doc.id,
-  });
-  fs.writeFileSync(localPath, content || '', 'utf-8');
-  lastKnownUpdate.set(trackingKey, remoteUpdated);
-  setTimeout(() => suppressLocal.delete(localPath), 1000);
-}
+  async function deleteFromFirestore(filePath) {
+    const { scope, teamId, docPath } = scopeFromLocalPath(filePath, LOCAL_PATH, teamIdsByName);
+    const trackingKey = `${scope}:${docPath}`;
+    lastKnownUpdate.delete(trackingKey);
 
-function startFirestoreListeners() {
-  console.log('Starting Firestore listeners...');
-
-  for (const [teamId, teamData] of teams) {
-    const teamFolder = teamData.name + ' Teamspace';
-    const q = query(filesRef, where('scope', '==', 'team'), where('teamId', '==', teamId));
-    onSnapshot(q, snapshot => {
-      snapshot.docChanges().forEach(change => {
-        handleFirestoreChange(change, (data) => {
-          return path.join(LOCAL_PATH, teamFolder, data.path);
-        }).catch(err => console.error('Firestore change handler error:', err && err.message));
-      });
-    }, err => console.error(`Team "${teamFolder}" listener error:`, err));
-    console.log(`  Listening: ${teamFolder}`);
-  }
+    const result = await deleteFileFromCloud({
+      filesRef,
+      storage,
+      orgId,
+      userId: USER_ID,
+      scope,
+      teamId,
+      docPath,
+    });
 
-  if (USER_ID) {
-    const privateQ = query(filesRef, where('scope', '==', 'private'), where('ownerId', '==', USER_ID));
-    onSnapshot(privateQ, snapshot => {
-      snapshot.docChanges().forEach(change => {
-        const data = change.doc.data();
-        const realPath = path.join(LOCAL_PATH, PRIVATE_FOLDER, data.path);
-
-        handleFirestoreChange(change, () => realPath)
-          .catch(err => console.error('Firestore change handler error:', err && err.message));
-
-        if (change.type !== 'removed') {
-          updateSharedByMeSymlink(data, realPath);
-        } else {
-          const symlinkPath = path.join(LOCAL_PATH, SHARED_BY_ME_FOLDER, data.path);
-          try { fs.lstatSync(symlinkPath); fs.unlinkSync(symlinkPath); } catch (e) { /* ok */ }
-        }
-      });
-    }, err => console.error('Private files listener error:', err));
-    console.log('  Listening: Private files + Shared by Me symlinks');
-
-    const sharedQ = query(filesRef, where('sharedWith', 'array-contains', USER_ID));
-    onSnapshot(sharedQ, snapshot => {
-      snapshot.docChanges().forEach(change => {
-        const data = change.doc.data();
-        if (data.ownerId === USER_ID) return;
-        handleFirestoreChange(change, () => {
-          return path.join(LOCAL_PATH, SHARED_WITH_ME_FOLDER, data.path);
-        }).catch(err => console.error('Firestore change handler error:', err && err.message));
-      });
-    }, err => console.error('Shared with me listener error:', err));
-    console.log('  Listening: Shared with Me');
+    if (result.action === 'deleted') {
+      console.log(`  [${orgId}] [local → firestore] DELETE ${docPath} (${scope})`);
+    }
   }
-}
 
-// --- Local → Firestore ---
-
-async function pushToFirestore(filePath, content) {
-  const { scope, teamId, docPath } = scopeFromLocalPath(filePath);
-  const trackingKey = `${scope}:${docPath}`;
-  const now = new Date().toISOString();
-  lastKnownUpdate.set(trackingKey, now);
-
-  const result = await pushFileToCloud({
-    filesRef,
-    storage,
-    orgId: ORG_ID,
-    userId: USER_ID,
-    scope,
-    teamId,
-    docPath,
-    content,
-    now,
-  });
+  function handleLocalChange(filePath) {
+    if (suppressLocal.has(filePath)) return;
 
-  if (result.action === 'created') {
-    console.log(`  [local → firestore] CREATE ${docPath} (${scope})`);
-  } else if (result.action === 'updated') {
-    console.log(`  [local → firestore] UPDATE ${docPath} (${scope})`);
-  }
-  if (result.storageError) {
-    console.error(`  [storage] upload failed for ${docPath}: ${result.storageError.message}`);
-  }
-}
+    const rel = path.relative(LOCAL_PATH, filePath);
+    if (!rel.endsWith('.md') && !rel.endsWith('.txt')) return;
 
-async function deleteFromFirestore(filePath) {
-  const { scope, teamId, docPath } = scopeFromLocalPath(filePath);
-  const trackingKey = `${scope}:${docPath}`;
-  lastKnownUpdate.delete(trackingKey);
-
-  const result = await deleteFileFromCloud({
-    filesRef,
-    storage,
-    orgId: ORG_ID,
-    userId: USER_ID,
-    scope,
-    teamId,
-    docPath,
-  });
+    if (rel.startsWith(SHARED_WITH_ME_FOLDER + path.sep)) return;
+    if (rel.startsWith(SHARED_BY_ME_FOLDER + path.sep)) return;
 
-  if (result.action === 'deleted') {
-    console.log(`  [local → firestore] DELETE ${docPath} (${scope})`);
+    const content = fs.readFileSync(filePath, 'utf-8');
+    pushToFirestore(filePath, content).catch(err => console.error(`  [${orgId}] Push error: ${err.message}`));
   }
-}
-
-function startLocalWatcher() {
-  console.log('Watching local files...');
-
-  const watcher = chokidar.watch(LOCAL_PATH, {
-    ignored: [
-      /(^|[\/\\])\./,
-      /node_modules/,
-      /\.csv$/,
-      /\.py$/,
-      /index\.html$/,
-    ],
-    persistent: true,
-    ignoreInitial: false,
-    followSymlinks: false,
-    awaitWriteFinish: {
-      stabilityThreshold: 500,
-      pollInterval: 100,
-    },
-  });
 
-  watcher.on('add', filePath => handleLocalChange(filePath));
-  watcher.on('change', filePath => handleLocalChange(filePath));
-  watcher.on('unlink', filePath => {
-    if (suppressLocal.has(filePath)) return;
-    deleteFromFirestore(filePath).catch(err => console.error(`Delete error: ${err.message}`));
-  });
-
-  watcher.on('ready', () => {
-    console.log('Local watcher ready.');
-  });
-}
-
-function handleLocalChange(filePath) {
-  if (suppressLocal.has(filePath)) return;
+  function startLocalWatcher() {
+    console.log(`  [${orgId}] Watching local files...`);
+
+    const watcher = chokidar.watch(LOCAL_PATH, {
+      ignored: [
+        /(^|[\/\\])\./,
+        /node_modules/,
+        /\.csv$/,
+        /\.py$/,
+        /index\.html$/,
+      ],
+      persistent: true,
+      ignoreInitial: false,
+      followSymlinks: false,
+      awaitWriteFinish: {
+        stabilityThreshold: 500,
+        pollInterval: 100,
+      },
+    });
 
-  const rel = path.relative(LOCAL_PATH, filePath);
-  if (!rel.endsWith('.md') && !rel.endsWith('.txt')) return;
+    watcher.on('add', filePath => handleLocalChange(filePath));
+    watcher.on('change', filePath => handleLocalChange(filePath));
+    watcher.on('unlink', filePath => {
+      if (suppressLocal.has(filePath)) return;
+      deleteFromFirestore(filePath).catch(err => console.error(`  [${orgId}] Delete error: ${err.message}`));
+    });
 
-  if (rel.startsWith(SHARED_WITH_ME_FOLDER + path.sep)) return;
-  if (rel.startsWith(SHARED_BY_ME_FOLDER + path.sep)) return;
+    watcher.on('ready', () => console.log(`  [${orgId}] Local watcher ready.`));
+  }
 
-  const content = fs.readFileSync(filePath, 'utf-8');
-  pushToFirestore(filePath, content).catch(err => console.error(`Push error: ${err.message}`));
+  startFirestoreListeners();
+  startLocalWatcher();
 }
 
 // --- Main ---
 
-console.log('');
-startFirestoreListeners();
-startLocalWatcher();
+for (const orgEntry of config.orgs) {
+  await setupOrgSync(orgEntry);
+}
 
 console.log('');
 console.log('Sync running. Press Ctrl+C to stop.');
-console.log(`  Local folders: ${[...teams.values()].map(t => t.name + ' Teamspace').join(', ')}, ${PRIVATE_FOLDER}, ${SHARED_WITH_ME_FOLDER}, ${SHARED_BY_ME_FOLDER}`);