@doubling/compound-sync 1.0.0

package/README.md

@@ -0,0 +1,51 @@
+# Compound Sync Daemon
+
+Bidirectional sync between Firestore and local markdown files.
+
+## Prerequisites
+
+- Node.js
+- Google Cloud Application Default Credentials: `gcloud auth application-default login`
+
+## Setup
+
+```bash
+cd sync
+npm install
+```
+
+Run the interactive setup for each environment:
+
+```bash
+node sync.js --config config-sandbox.json --setup   # Project: doubling-compound-sandbox
+node sync.js --config config-dev.json --setup        # Project: doubling-compound-dev
+node sync.js --config config-prod.json --setup       # Project: doubling-compound-prod
+```
+
+The setup wizard will ask for:
+- **Firebase project ID** (e.g. `doubling-compound-sandbox`)
+- **Organization** to sync
+- **Email address** for private file sync
+- **Local sync folder** (e.g. `~/Compound-sandbox`)
+
+Config files (`config-*.json`) are gitignored and stored locally.
+
+## Running
+
+Run one or more environments in separate terminal tabs:
+
+```bash
+node sync.js --config config-sandbox.json
+node sync.js --config config-dev.json
+node sync.js --config config-prod.json
+```
+
+## Local folder structure
+
+```
+{Sync Folder}/
+  {TeamName} Teamspace/   -- team files (bidirectional)
+  Private/                 -- your private files (bidirectional)
+  Shared by Me/            -- symlinks to files you've shared
+  Shared with Me/          -- files shared with you (read-only)
+```

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "@doubling/compound-sync",
+  "version": "1.0.0",
+  "description": "Bidirectional sync between Compound and local markdown files",
+  "type": "module",
+  "bin": {
+    "compound-sync": "./sync.js"
+  },
+  "scripts": {
+    "sync": "node sync.js"
+  },
+  "dependencies": {
+    "firebase": "^11.7.0",
+    "chokidar": "^4.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/sync.js

@@ -0,0 +1,697 @@
+#!/usr/bin/env node
+
+/**
+ * Bidirectional sync between Firestore files and local markdown files.
+ * Uses Firebase client SDK with browser-based auth — no gcloud needed.
+ *
+ * Local folder structure:
+ *   {SyncFolder}/
+ *     {TeamName} Teamspace/   ← team files (bidirectional)
+ *     Private/                ← user's private files (bidirectional)
+ *     Shared by Me/           ← symlinks to files you've shared
+ *     Shared with Me/         ← files shared with you (read-only)
+ *
+ * Usage: node sync.js [--config <file>] [--setup]
+ */
+
+import { initializeApp } from 'firebase/app';
+import { getAuth, signInWithEmailAndPassword, signInWithCredential, GoogleAuthProvider } from 'firebase/auth';
+import {
+  getFirestore, collection, doc, getDocs, getDoc, addDoc, updateDoc, deleteDoc,
+  query, where, onSnapshot
+} from 'firebase/firestore';
+import chokidar from 'chokidar';
+import fs from 'fs';
+import path from 'path';
+import readline from 'readline';
+import os from 'os';
+import http from 'http';
+import { exec } from 'child_process';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+// --- Firebase configs (same as the web app) ---
+
+const firebaseConfigs = {
+  'doubling-compound-sandbox': {
+    apiKey: "AIzaSyBnskQNh--bRaRN7tsVFbb01oll8OSdVH8",
+    authDomain: "doubling-compound-sandbox.firebaseapp.com",
+    projectId: "doubling-compound-sandbox",
+    storageBucket: "doubling-compound-sandbox.firebasestorage.app",
+    messagingSenderId: "83118259611",
+    appId: "1:83118259611:web:cf9cda61c9ecdc161b353e"
+  },
+  'doubling-compound-dev': {
+    apiKey: "AIzaSyBPKJqfy77_qmP_x9zOVzoHKuY8PHFCUm0",
+    authDomain: "doubling-compound-dev.firebaseapp.com",
+    projectId: "doubling-compound-dev",
+    storageBucket: "doubling-compound-dev.firebasestorage.app",
+    messagingSenderId: "967509355891",
+    appId: "1:967509355891:web:c253ebdb8205d3ef012906"
+  },
+  'doubling-compound-prod': {
+    apiKey: "AIzaSyDvnPV5dLxzubPE8pwq_S80gMsF8E97LaI",
+    authDomain: "compound.doubling.io",
+    projectId: "doubling-compound-prod",
+    storageBucket: "doubling-compound-prod.firebasestorage.app",
+    messagingSenderId: "831648925388",
+    appId: "1:831648925388:web:87550a55f807f2a2a1a469"
+  }
+};
+
+// --- Helpers ---
+
+function ask(question) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise(resolve => {
+    rl.question(question, answer => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+function expandHome(p) {
+  if (p.startsWith('~/')) return path.join(os.homedir(), p.slice(2));
+  return p;
+}
+
+function openBrowser(url) {
+  const cmd = process.platform === 'darwin' ? 'open' :
+    process.platform === 'win32' ? 'start' : 'xdg-open';
+  exec(`${cmd} "${url}"`);
+}
+
+// --- Browser-based auth ---
+
+function buildLoginPage(fbConfig) {
+  return `<!DOCTYPE html>
+<html><head><meta charset="utf-8"><title>Compound Sync - Sign In</title>
+<style>
+  body { font-family: -apple-system, system-ui, sans-serif; max-width: 400px; margin: 80px auto; text-align: center; }
+  h2 { margin-bottom: 8px; }
+  p { color: #666; margin-bottom: 32px; }
+  button { display: block; width: 100%; padding: 12px; margin: 8px 0; border: 1px solid #ddd; border-radius: 8px;
+    background: white; font-size: 16px; cursor: pointer; }
+  button:hover { background: #f5f5f5; }
+  .google { font-weight: 500; }
+  .divider { color: #999; margin: 16px 0; }
+  input { display: block; width: 100%; padding: 12px; margin: 8px 0; border: 1px solid #ddd; border-radius: 8px;
+    font-size: 16px; box-sizing: border-box; }
+  .error { color: red; margin: 8px 0; }
+  .success { color: green; font-size: 18px; margin-top: 40px; }
+</style>
+</head><body>
+<h2>Compound Sync</h2>
+<p>Sign in to start syncing</p>
+<div id="login">
+  <button class="google" onclick="googleSignIn()">Sign in with Google</button>
+  <div class="divider">or sign in with email</div>
+  <input id="email" type="email" placeholder="Email">
+  <input id="password" type="password" placeholder="Password">
+  <button onclick="emailSignIn()">Sign in</button>
+  <div id="error" class="error"></div>
+</div>
+<div id="done" class="success" style="display:none">
+  Signed in! You can close this tab.
+</div>
+
+<script type="module">
+import { initializeApp } from 'https://www.gstatic.com/firebasejs/11.7.1/firebase-app.js';
+import { getAuth, signInWithPopup, signInWithEmailAndPassword, GoogleAuthProvider }
+  from 'https://www.gstatic.com/firebasejs/11.7.1/firebase-auth.js';
+
+const fbConfig = ${JSON.stringify(fbConfig)};
+const app = initializeApp(fbConfig);
+const auth = getAuth(app);
+
+async function sendCredential(data) {
+  await fetch('/auth-callback', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(data),
+  });
+  document.getElementById('login').style.display = 'none';
+  document.getElementById('done').style.display = 'block';
+}
+
+window.googleSignIn = async function() {
+  try {
+    const result = await signInWithPopup(auth, new GoogleAuthProvider());
+    const credential = GoogleAuthProvider.credentialFromResult(result);
+    await sendCredential({
+      method: 'google',
+      idToken: credential.idToken,
+      accessToken: credential.accessToken,
+    });
+  } catch (err) {
+    document.getElementById('error').textContent = err.message;
+  }
+};
+
+window.emailSignIn = async function() {
+  const email = document.getElementById('email').value;
+  const password = document.getElementById('password').value;
+  try {
+    await signInWithEmailAndPassword(auth, email, password);
+    await sendCredential({ method: 'email', email, password });
+  } catch (err) {
+    document.getElementById('error').textContent = err.message;
+  }
+};
+</script>
+</body></html>`;
+}
+
+function browserAuth(fbConfig) {
+  return new Promise((resolve, reject) => {
+    const server = http.createServer((req, res) => {
+      if (req.method === 'GET' && req.url === '/login') {
+        res.writeHead(200, { 'Content-Type': 'text/html' });
+        res.end(buildLoginPage(fbConfig));
+        return;
+      }
+
+      if (req.method === 'POST' && req.url === '/auth-callback') {
+        let body = '';
+        req.on('data', chunk => { body += chunk; });
+        req.on('end', () => {
+          res.writeHead(200, { 'Content-Type': 'text/plain' });
+          res.end('OK');
+          server.close();
+          resolve(JSON.parse(body));
+        });
+        return;
+      }
+
+      res.writeHead(404);
+      res.end('Not found');
+    });
+
+    server.listen(0, () => {
+      const port = server.address().port;
+      const url = `http://localhost:${port}/login`;
+      console.log(`Opening browser for sign-in...`);
+      console.log(`If the browser doesn't open, visit: ${url}`);
+      openBrowser(url);
+    });
+  });
+}
+
+// --- Interactive setup ---
+
+async function setupConfig() {
+  console.log('');
+  console.log('Welcome to the Compound sync daemon! Let\'s set things up.');
+  console.log('');
+
+  // Default to prod; --env flag overrides for internal use
+  const projectId = envOverride || 'doubling-compound-prod';
+
+  const fbConfig = firebaseConfigs[projectId];
+
+  // Browser sign-in to discover orgs
+  console.log('');
+  const authResult = await browserAuth(fbConfig);
+  const app = initializeApp(fbConfig, 'setup');
+  const auth = getAuth(app);
+  const db = getFirestore(app);
+
+  let userCredential;
+  if (authResult.method === 'google') {
+    const credential = GoogleAuthProvider.credential(authResult.idToken, authResult.accessToken);
+    userCredential = await signInWithCredential(auth, credential);
+  } else {
+    userCredential = await signInWithEmailAndPassword(auth, authResult.email, authResult.password);
+  }
+
+  const userId = userCredential.user.uid;
+  const userEmail = userCredential.user.email;
+  console.log(`Signed in as ${userEmail}`);
+
+  // List available orgs for this user
+  console.log('');
+  console.log('Fetching your organizations...');
+  const membersSnapshot = await getDocs(
+    query(collection(db, 'orgMembers'), where('userId', '==', userId))
+  );
+
+  const orgIds = [];
+  membersSnapshot.forEach(doc => {
+    orgIds.push(doc.data().orgId);
+  });
+
+  if (orgIds.length === 0) {
+    console.error('No organizations found for your account.');
+    process.exit(1);
+  }
+
+  const orgs = [];
+  for (const orgId of orgIds) {
+    const orgDoc = await getDoc(doc(db, 'orgs', orgId));
+    if (orgDoc.exists()) {
+      orgs.push({ id: orgDoc.id, ...orgDoc.data() });
+    }
+  }
+
+  console.log('');
+  console.log('Your organizations:');
+  orgs.forEach((org, i) => {
+    console.log(`  ${i + 1}. ${org.name}`);
+  });
+  console.log('');
+
+  let orgId;
+  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);
+    }
+  } 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);
+    }
+    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);
+    }
+  }
+
+  // Save config (no credentials stored)
+  const savedConfig = {
+    projectId,
+    orgId,
+    localPath: resolvedPath,
+    _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;
+}
+
+// --- Config ---
+
+const args = process.argv.slice(2);
+let configFile = 'config.json';
+let forceSetup = false;
+let envOverride = null;
+for (let i = 0; i < args.length; i++) {
+  if (args[i] === '--config' && args[i + 1]) { configFile = args[++i]; }
+  if (args[i] === '--setup') { forceSetup = true; }
+  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'));
+}
+if (forceSetup) { config = {}; }
+
+// Interactive setup if no config
+if (!config.projectId || !config.orgId) {
+  config = await setupConfig();
+}
+
+// --- Initialize Firebase client SDK ---
+
+let app, db, userId;
+
+if (config._app) {
+  // Reuse app and auth from setup
+  app = config._app;
+  db = config._db;
+  userId = config._userId;
+} else {
+  const fbConfig = firebaseConfigs[config.projectId];
+  if (!fbConfig) {
+    console.error(`Unknown project: ${config.projectId}`);
+    process.exit(1);
+  }
+
+  app = initializeApp(fbConfig);
+  const auth = getAuth(app);
+  db = getFirestore(app);
+
+  // Sign in via browser
+  console.log('');
+  const authResult = await browserAuth(fbConfig);
+
+  if (authResult.method === 'google') {
+    const credential = GoogleAuthProvider.credential(authResult.idToken, authResult.accessToken);
+    const cred = await signInWithCredential(auth, credential);
+    userId = cred.user.uid;
+    console.log(`Signed in as ${cred.user.email}`);
+  } else {
+    const cred = await signInWithEmailAndPassword(auth, authResult.email, authResult.password);
+    userId = cred.user.uid;
+    console.log(`Signed in as ${cred.user.email}`);
+  }
+}
+
+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`);
+
+// --- 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'}`);
+
+// --- Scope-aware path helpers ---
+
+const PRIVATE_FOLDER = 'Private';
+const SHARED_WITH_ME_FOLDER = 'Shared with Me';
+const SHARED_BY_ME_FOLDER = 'Shared by Me';
+
+const lastKnownUpdate = new Map();
+const suppressLocal = new Set();
+
+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);
+      }
+    } 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(`  [symlink] removed Shared by Me/${fileDoc.path}`);
+      }
+    } catch (e) { /* doesn't exist */ }
+  }
+}
+
+function scopeFromLocalPath(filePath) {
+  const rel = path.relative(LOCAL_PATH, 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') ? folderName.slice(0, -' Teamspace'.length) : folderName;
+  const teamId = teamIdsByName.get(teamName);
+  return { scope: 'team', teamId, docPath: parts.slice(1).join('/') };
+}
+
+function ensureDir(filePath) {
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+
+// --- Create local folder structure ---
+
+function ensureFolderStructure() {
+  const privatePath = path.join(LOCAL_PATH, PRIVATE_FOLDER);
+  if (!fs.existsSync(privatePath)) fs.mkdirSync(privatePath, { recursive: true });
+
+  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 });
+
+  for (const [, teamData] of teams) {
+    const teamPath = path.join(LOCAL_PATH, teamData.name + ' Teamspace');
+    if (!fs.existsSync(teamPath)) fs.mkdirSync(teamPath, { recursive: true });
+  }
+}
+
+ensureFolderStructure();
+
+// --- Firestore → Local (multiple listeners) ---
+
+function handleFirestoreChange(change, getLocalPath) {
+  const data = change.doc.data();
+  const docPath = data.path;
+  if (!docPath) return;
+
+  const localPath = getLocalPath(data);
+  const trackingKey = `${data.scope || 'team'}:${docPath}`;
+
+  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);
+    }
+    lastKnownUpdate.delete(trackingKey);
+    return;
+  }
+
+  const remoteUpdated = data.updatedAt || data.createdAt || '';
+  const lastKnown = lastKnownUpdate.get(trackingKey);
+
+  if (lastKnown && lastKnown >= remoteUpdated) return;
+
+  if (fs.existsSync(localPath)) {
+    const localMtime = fs.statSync(localPath).mtime.toISOString();
+    if (localMtime > remoteUpdated) return;
+  }
+
+  const action = change.type === 'added' ? 'CREATE' : 'UPDATE';
+  console.log(`  [firestore → local] ${action} ${docPath} (${data.scope || 'team'})`);
+  ensureDir(localPath);
+  suppressLocal.add(localPath);
+  fs.writeFileSync(localPath, data.content || '', 'utf-8');
+  lastKnownUpdate.set(trackingKey, remoteUpdated);
+  setTimeout(() => suppressLocal.delete(localPath), 1000);
+}
+
+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);
+        });
+      });
+    }, err => console.error(`Team "${teamFolder}" listener error:`, err));
+    console.log(`  Listening: ${teamFolder}`);
+  }
+
+  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);
+
+        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);
+        });
+      });
+    }, err => console.error('Shared with me listener error:', err));
+    console.log('  Listening: Shared with Me');
+  }
+}
+
+// --- 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);
+
+  if (scope === 'shared-with-me' || scope === 'shared-by-me') return;
+
+  let snapshot;
+  if (scope === 'private') {
+    snapshot = await getDocs(query(filesRef,
+      where('scope', '==', 'private'),
+      where('ownerId', '==', USER_ID),
+      where('path', '==', docPath)
+    ));
+  } else if (scope === 'team' && teamId) {
+    snapshot = await getDocs(query(filesRef,
+      where('scope', '==', 'team'),
+      where('teamId', '==', teamId),
+      where('path', '==', docPath)
+    ));
+  } else {
+    snapshot = await getDocs(query(filesRef, where('path', '==', docPath)));
+  }
+
+  if (!snapshot || snapshot.empty) {
+    console.log(`  [local → firestore] CREATE ${docPath} (${scope})`);
+    const fileData = {
+      path: docPath,
+      content,
+      createdAt: now,
+      updatedAt: now,
+      scope,
+      teamId: scope === 'team' ? (teamId || null) : null,
+      ownerId: scope === 'private' ? USER_ID : null,
+      sharedWith: [],
+    };
+    await addDoc(filesRef, fileData);
+  } else {
+    const docSnap = snapshot.docs[0];
+    const existing = docSnap.data();
+    if (existing.content === content) return;
+    console.log(`  [local → firestore] UPDATE ${docPath} (${scope})`);
+    await updateDoc(docSnap.ref, { content, updatedAt: now });
+  }
+}
+
+async function deleteFromFirestore(filePath) {
+  const { scope, teamId, docPath } = scopeFromLocalPath(filePath);
+  const trackingKey = `${scope}:${docPath}`;
+  lastKnownUpdate.delete(trackingKey);
+
+  if (scope === 'shared-with-me' || scope === 'shared-by-me') return;
+
+  const snapshot = await getDocs(query(filesRef, where('path', '==', docPath)));
+  if (!snapshot.empty) {
+    const data = snapshot.docs[0].data();
+    if ((data.scope || 'team') === scope) {
+      console.log(`  [local → firestore] DELETE ${docPath} (${scope})`);
+      await deleteDoc(snapshot.docs[0].ref);
+    }
+  }
+}
+
+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;
+
+  const rel = path.relative(LOCAL_PATH, filePath);
+  if (!rel.endsWith('.md') && !rel.endsWith('.txt')) return;
+
+  if (rel.startsWith(SHARED_WITH_ME_FOLDER + path.sep)) return;
+  if (rel.startsWith(SHARED_BY_ME_FOLDER + path.sep)) return;
+
+  const content = fs.readFileSync(filePath, 'utf-8');
+  pushToFirestore(filePath, content).catch(err => console.error(`Push error: ${err.message}`));
+}
+
+// --- Main ---
+
+console.log('');
+startFirestoreListeners();
+startLocalWatcher();
+
+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}`);