pal-explorer-cli 0.4.7 → 0.4.8

package/lib/commands/sync.js

@@ -1,7 +1,6 @@
 import chalk from 'chalk';
 import path from 'path';
 import fs from 'fs';
-import os from 'os';
 import config from '../utils/config.js';
 import logger from '../utils/logger.js';
 import { buildManifest as buildDiffManifest, diffManifests as diffFileManifests, diffSummary } from '../core/fileDiff.js';
@@ -13,6 +12,7 @@ import {
   detectConflicts,
   applyDiff,
   formatSize,
+  SyncSession,
 } from '../core/syncEngine.js';
 import {
   getSyncPairs,
@@ -26,7 +26,9 @@ import {
   addSyncHistoryEntry,
   getSyncHistory,
 } from '../core/syncState.js';
-import { getPrimaryServer } from '../core/discoveryClient.js';
+import { selectSyncTransport } from '../core/syncTransport.js';
+import { registerSyncHandlers } from '../core/syncProtocolHandlers.js';
+import { parseSyncOptions, addSyncFlagsToCommand } from '../core/syncOptions.js';
 
 function getIdentity() {
   const identity = config.get('identity');
@@ -36,6 +38,17 @@ function getIdentity() {
   return identity;
 }
 
+function getKeyPair() {
+  const identity = config.get('identity');
+  if (!identity?.publicKey || !identity?.privateKey) {
+    throw new Error('Identity keys not configured. Run `pe init` first.');
+  }
+  return {
+    publicKey: Buffer.from(identity.publicKey, 'hex'),
+    secretKey: Buffer.from(identity.privateKey, 'hex'),
+  };
+}
+
 function findPal(palName) {
   const friends = getFriends();
   const pal = friends.find(f => f.name === palName || f.id === palName || f.handle === palName);
@@ -56,68 +69,156 @@ function validateDir(dirPath) {
   return abs;
 }
 
-async function sendMessage(toHandle, body) {
-  const identity = getIdentity();
-  const serverUrl = getPrimaryServer();
-  const res = await fetch(`${serverUrl}/messages`, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({
-      toHandle,
-      fromHandle: identity.handle,
-      payload: body,
-    }),
-    signal: AbortSignal.timeout(15000),
-  });
-  if (!res.ok) {
-    const err = await res.json().catch(() => ({}));
-    throw new Error(`Discovery server error: ${res.status} ${err.error || res.statusText}`);
+function printDiffSummary(diff, verbose) {
+  if (diff.added.length) {
+    console.log(chalk.green(`    + ${diff.added.length} new file(s)`));
+    if (verbose) diff.added.forEach(a => console.log(chalk.green(`      + ${a.relativePath}`)));
+  }
+  if (diff.modified.length) {
+    console.log(chalk.yellow(`    ~ ${diff.modified.length} modified file(s)`));
+    if (verbose) diff.modified.forEach(m => console.log(chalk.yellow(`      ~ ${m.relativePath}`)));
+  }
+  if (diff.deleted.length) {
+    console.log(chalk.red(`    - ${diff.deleted.length} deleted file(s)`));
+    if (verbose) diff.deleted.forEach(d => console.log(chalk.red(`      - ${d.relativePath}`)));
+  }
+  if ((diff.conflicts || []).length) {
+    console.log(chalk.magenta(`    ! ${diff.conflicts.length} conflict(s)`));
+    if (verbose) diff.conflicts.forEach(c => console.log(chalk.magenta(`      ! ${c.relativePath}`)));
+  }
+  if ((diff.skipped || []).length && verbose) {
+    console.log(chalk.gray(`    = ${diff.skipped.length} skipped`));
   }
 }
 
-async function getMessages() {
-  const identity = getIdentity();
-  const serverUrl = getPrimaryServer();
-  const timestamp = String(Date.now());
-  const message = `${identity.handle}:${timestamp}`;
-  let headers = {};
-  try {
-    const { signMessage } = await import('../crypto/chatEncryption.js');
-    const pk = identity.publicKey;
-    const sk = config.get('identity')?.privateKey || (await import('../core/identity.js')).then(m => m.getIdentity()).then(i => i?.privateKey);
-    const privateKey = typeof sk === 'string' ? sk : await sk;
-    if (privateKey) {
-      const sig = signMessage(message, privateKey);
-      headers = { 'x-public-key': pk, 'x-timestamp': timestamp, 'x-signature': sig };
+function printResults(results) {
+  if (results.copied.length) console.log(chalk.green(`  Copied ${results.copied.length} file(s)`));
+  if (results.deleted.length) console.log(chalk.red(`  Deleted ${results.deleted.length} file(s)`));
+  if (results.skipped?.length) console.log(chalk.gray(`  Skipped ${results.skipped.length} file(s)`));
+  if (results.conflicted.length) {
+    console.log(chalk.magenta(`  ${results.conflicted.length} conflict(s) saved with .sync-conflict suffix`));
+    for (const c of results.conflicted) {
+      if (c.original) console.log(chalk.gray(`    ${c.original} -> ${c.conflictFile}`));
     }
-  } catch {}
-  const res = await fetch(`${serverUrl}/messages/${encodeURIComponent(identity.handle)}`, { headers, signal: AbortSignal.timeout(10000) });
-  if (!res.ok) {
-    throw new Error(`Discovery server error: ${res.status} ${res.statusText}`);
   }
-  return res.json();
+  if (results.errors.length) {
+    console.log(chalk.red(`  ${results.errors.length} error(s):`));
+    for (const e of results.errors) console.log(chalk.red(`    ${e.file}: ${e.error}`));
+  }
+}
+
+// --- pe sync <path> <pal> (bi-directional, default) ---
+
+async function biSync(dirPath, palName, opts) {
+  let absolutePath, pal, identity, keyPair;
+  try {
+    absolutePath = validateDir(dirPath);
+    pal = findPal(palName);
+    identity = getIdentity();
+    keyPair = getKeyPair();
+  } catch (err) {
+    console.log(chalk.red(err.message));
+    process.exitCode = 1;
+    return;
+  }
+
+  const options = parseSyncOptions(opts);
+  const palHandle = pal.handle || pal.name;
+  const palId = pal.id || pal.publicKey;
+
+  registerSyncHandlers();
+
+  console.log(chalk.blue(`Syncing ${absolutePath} with ${pal.name}...`));
+
+  let transport;
+  try {
+    transport = await selectSyncTransport(palId, { peerHandle: palHandle });
+    console.log(chalk.gray(`  Transport: ${transport.type}`));
+  } catch (err) {
+    console.log(chalk.red(`Cannot reach ${pal.name}: ${err.message}`));
+    process.exitCode = 1;
+    return;
+  }
+
+  const existingPair = findSyncPair(absolutePath, palId);
+  const cachedManifest = existingPair ? getSyncManifest(existingPair.id) : null;
+  const pair = addSyncPair(absolutePath, palId, `sync:${palHandle}`);
+
+  const session = new SyncSession({
+    localPath: absolutePath,
+    peerPK: palId,
+    transport,
+    keyPair,
+    syncPairId: pair.id,
+    options,
+  });
+
+  if (options.progress) {
+    session.on('state', (s) => console.log(chalk.gray(`  [${s}]`)));
+    session.on('manifestSent', (d) => console.log(chalk.gray(`  Sent manifest (${d.entries} files)`)));
+    session.on('manifestReceived', (d) => console.log(chalk.gray(`  Received manifest (${d.entries} files)`)));
+  }
+
+  try {
+    const { localManifest } = await session.start(cachedManifest);
+    console.log(chalk.gray(`  ${localManifest.length} local file(s) indexed`));
+
+    // For bi-directional sync, we need the remote manifest
+    // In real P2P: remote peer would respond with their manifest
+    // Here we send ours and wait for theirs
+    console.log(chalk.blue(`  Waiting for ${pal.name}'s manifest...`));
+    console.log(chalk.gray('  (Manifest sent via PAL/1.0 protocol)'));
+
+    // Save local state
+    saveSyncManifest(pair.id, localManifest);
+    updateSyncPair(pair.id, {
+      lastSync: new Date().toISOString(),
+      status: 'synced',
+      lastDirection: 'sync',
+    });
+
+    addSyncHistoryEntry(pair.id, {
+      direction: 'sync',
+      totalFiles: localManifest.length,
+    });
+
+    session.finish();
+    console.log(chalk.green(`Sync manifest sent to ${pal.name}.`));
+    console.log(chalk.gray(`Sync pair: ${pair.id}`));
+  } catch (err) {
+    session.abort(err.message);
+    updateSyncPair(pair.id, { status: 'error' });
+    logger.error(`Sync failed: ${err.message}`);
+    console.log(chalk.red(`Sync failed: ${err.message}`));
+    process.exitCode = 1;
+  }
 }
 
 // --- pe sync push <path> <pal> ---
 
-async function pushSync(dirPath, palName) {
-  let absolutePath, pal;
+async function pushSync(dirPath, palName, opts) {
+  let absolutePath, pal, identity, keyPair;
   try {
     absolutePath = validateDir(dirPath);
     pal = findPal(palName);
+    identity = getIdentity();
+    keyPair = getKeyPair();
   } catch (err) {
     console.log(chalk.red(err.message));
     process.exitCode = 1;
     return;
   }
 
+  const options = parseSyncOptions(opts);
   const palHandle = pal.handle || pal.name;
-  const palId = pal.id;
+  const palId = pal.id || pal.publicKey;
+
+  registerSyncHandlers();
 
   console.log(chalk.blue(`Scanning ${absolutePath}...`));
   const existingPair = findSyncPair(absolutePath, palId);
   const cachedManifest = existingPair ? getSyncManifest(existingPair.id) : null;
-  const manifest = await buildManifest(absolutePath, cachedManifest);
+  const manifest = await buildManifest(absolutePath, cachedManifest, options);
   console.log(chalk.gray(`  ${manifest.length} file(s) indexed`));
 
   const pair = addSyncPair(absolutePath, palId, `sync:${palHandle}`);
@@ -142,60 +243,33 @@ async function pushSync(dirPath, palName) {
     console.log(chalk.gray('  First sync for this pair.'));
   }
 
-  // Look up or create a share for this directory so we have a magnet link
-  let allShares = config.get('shares') || [];
-  let dirShare = allShares.find(s => s.path === absolutePath && s.magnet);
-  let magnet = dirShare?.magnet || null;
-
-  // If no share exists, auto-create a hidden sync share
-  if (!dirShare) {
-    const existing = allShares.find(s => s.path === absolutePath);
-    if (!existing) {
-      const { addShare } = await import('../core/shares.js');
-      try {
-        const autoShare = addShare(absolutePath, 'folder', 'private', { read: true }, [{ name: pal.name, id: palId, handle: palHandle }], { recursive: true });
-        autoShare.syncHidden = true;
-        allShares = config.get('shares') || [];
-        const idx = allShares.findIndex(s => s.id === autoShare.id);
-        if (idx !== -1) { allShares[idx].syncHidden = true; config.set('shares', allShares); }
-        console.log(chalk.gray(`  Auto-created sync share for ${path.basename(absolutePath)}`));
-      } catch {}
-    }
+  if (options.dryRun) {
+    console.log(chalk.yellow('Dry run — no changes sent.'));
+    return;
   }
 
-  // Seed the directory to get a magnet link if we don't have one
-  if (!magnet) {
-    console.log(chalk.blue('Seeding directory for P2P sync...'));
-    try {
-      const WebTorrent = (await import('webtorrent')).default;
-      const client = new WebTorrent();
-      magnet = await new Promise((resolve, reject) => {
-        const timeout = setTimeout(() => { client.destroy(); reject(new Error('Seed timeout')); }, 30000);
-        client.seed(absolutePath, { name: path.basename(absolutePath) }, (torrent) => {
-          clearTimeout(timeout);
-          // Persist magnet to share config
-          const shares = config.get('shares') || [];
-          const entry = shares.find(s => s.path === absolutePath);
-          if (entry) { entry.magnet = torrent.magnetURI; config.set('shares', shares); }
-          console.log(chalk.green(`  Seeding: ${torrent.magnetURI.slice(0, 60)}...`));
-          // Keep seeding in background (don't destroy client)
-          resolve(torrent.magnetURI);
-        });
-      });
-    } catch (err) {
-      console.log(chalk.yellow(`  Could not seed: ${err.message}. Sending manifest without magnet.`));
-    }
+  // Select transport and send via PAL/1.0 protocol
+  let transport;
+  try {
+    transport = await selectSyncTransport(palId, { peerHandle: palHandle });
+    console.log(chalk.gray(`  Transport: ${transport.type}`));
+  } catch (err) {
+    console.log(chalk.red(`Cannot reach ${pal.name}: ${err.message}`));
+    process.exitCode = 1;
+    return;
   }
 
-  console.log(chalk.blue(`Sending manifest to ${pal.name}...`));
+  const session = new SyncSession({
+    localPath: absolutePath,
+    peerPK: palId,
+    transport,
+    keyPair,
+    syncPairId: pair.id,
+    options,
+  });
+
   try {
-    await sendMessage(palHandle, {
-      type: 'sync-manifest',
-      syncPairId: pair.id,
-      manifest,
-      magnet,
-      timestamp: new Date().toISOString(),
-    });
+    await session.start(cachedManifest);
 
     saveSyncManifest(pair.id, manifest);
     updateSyncPair(pair.id, {
@@ -212,220 +286,196 @@ async function pushSync(dirPath, palName) {
       totalFiles: manifest.length,
     });
 
+    session.finish();
     console.log(chalk.green(`Push complete. Manifest sent to ${pal.name}.`));
     console.log(chalk.gray(`Sync pair: ${pair.id}`));
-    console.log(chalk.gray('Pal can run `pe sync pull` to fetch changes.'));
   } catch (err) {
+    session.abort(err.message);
     updateSyncPair(pair.id, { status: 'error' });
     logger.error(`Push sync failed: ${err.message}`);
-    console.log(chalk.yellow(`Could not reach discovery server: ${err.message}`));
-    console.log(chalk.gray('Manifest built locally. Will sync when server is available.'));
+    console.log(chalk.red(`Push failed: ${err.message}`));
     process.exitCode = 1;
   }
 }
 
 // --- pe sync pull <path> <pal> ---
 
-async function pullSync(dirPath, palName) {
-  let absolutePath, pal;
+async function pullSync(dirPath, palName, opts) {
+  let absolutePath, pal, identity, keyPair;
   try {
     absolutePath = validateDir(dirPath);
     pal = findPal(palName);
+    identity = getIdentity();
+    keyPair = getKeyPair();
   } catch (err) {
     console.log(chalk.red(err.message));
     process.exitCode = 1;
     return;
   }
 
+  const options = parseSyncOptions(opts);
   const palHandle = pal.handle || pal.name;
-  const palId = pal.id;
+  const palId = pal.id || pal.publicKey;
+
+  registerSyncHandlers();
 
-  console.log(chalk.blue(`Checking messages from ${pal.name}...`));
+  console.log(chalk.blue(`Pulling from ${pal.name} to ${absolutePath}...`));
 
-  let messages;
+  let transport;
   try {
-    messages = await getMessages();
+    transport = await selectSyncTransport(palId, { peerHandle: palHandle });
+    console.log(chalk.gray(`  Transport: ${transport.type}`));
   } catch (err) {
-    logger.error(`Pull sync failed: ${err.message}`);
-    console.log(chalk.red(`Could not reach discovery server: ${err.message}`));
+    console.log(chalk.red(`Cannot reach ${pal.name}: ${err.message}`));
     process.exitCode = 1;
     return;
   }
 
-  const syncMessages = (Array.isArray(messages) ? messages : [])
-    .map(m => {
-      try {
-        let data = m.payload || m.body;
-        // Handle double-encoded JSON (string of JSON string)
-        if (typeof data === 'string') {
-          data = JSON.parse(data);
-          if (typeof data === 'string') data = JSON.parse(data);
-        }
-        return { ...m, parsed: data };
-      } catch { return null; }
-    })
-    .filter(m => m && m.parsed?.type === 'sync-manifest' && (m.fromHandle || m.from) === palHandle)
-    .sort((a, b) => new Date(b.parsed.timestamp) - new Date(a.parsed.timestamp));
-
-  if (syncMessages.length === 0) {
-    console.log(chalk.yellow(`No sync manifests from ${pal.name}. Ask them to run \`pe sync push\`.`));
-    return;
-  }
-
-  const latest = syncMessages[0].parsed;
-  const remoteManifest = latest.manifest;
-  console.log(chalk.gray(`  Found manifest from ${latest.timestamp} (${remoteManifest.length} files)`));
+  const existingPair = findSyncPair(absolutePath, palId);
+  const cachedManifest = existingPair ? getSyncManifest(existingPair.id) : null;
+  const pair = addSyncPair(absolutePath, palId, `sync:${palHandle}`);
 
-  console.log(chalk.blue(`Scanning local ${absolutePath}...`));
-  const existingPullPair = findSyncPair(absolutePath, palId);
-  const cachedPullManifest = existingPullPair ? getSyncManifest(existingPullPair.id) : null;
-  const localManifest = await buildManifest(absolutePath, cachedPullManifest);
-  console.log(chalk.gray(`  ${localManifest.length} local file(s)`));
+  const session = new SyncSession({
+    localPath: absolutePath,
+    peerPK: palId,
+    transport,
+    keyPair,
+    syncPairId: pair.id,
+    options,
+  });
 
-  const localMap = manifestToMap(localManifest);
-  const remoteMap = manifestToMap(remoteManifest);
+  try {
+    // Start session (sends our manifest to peer)
+    const { localManifest } = await session.start(cachedManifest);
+    console.log(chalk.gray(`  ${localManifest.length} local file(s) indexed`));
+    console.log(chalk.blue(`  Manifest sent, waiting for ${pal.name}'s response...`));
+    console.log(chalk.gray('  (Pull request sent via PAL/1.0 protocol)'));
 
-  const pair = addSyncPair(absolutePath, palId, `sync:${palHandle}`);
-  const baseMap = getLastSyncedManifestMap(pair.id);
+    saveSyncManifest(pair.id, localManifest);
+    updateSyncPair(pair.id, {
+      lastSync: new Date().toISOString(),
+      status: 'synced',
+      lastDirection: 'pull',
+    });
 
-  const { conflicts } = detectConflicts(localMap, remoteMap, baseMap);
-  const diff = diffManifests(localMap, remoteMap);
+    addSyncHistoryEntry(pair.id, {
+      direction: 'pull',
+      totalFiles: localManifest.length,
+    });
 
-  if (conflicts.length > 0) {
-    diff.conflicts = conflicts;
-    diff.modified = diff.modified.filter(
-      m => !conflicts.some(c => c.relativePath === m.relativePath)
-    );
+    session.finish();
+    console.log(chalk.green(`Pull request sent to ${pal.name}.`));
+  } catch (err) {
+    session.abort(err.message);
+    updateSyncPair(pair.id, { status: 'error' });
+    logger.error(`Pull sync failed: ${err.message}`);
+    console.log(chalk.red(`Pull failed: ${err.message}`));
+    process.exitCode = 1;
   }
+}
+
+// --- pe sync watch <path> <pal> ---
 
-  const totalChanges = diff.added.length + diff.modified.length + diff.deleted.length + (diff.conflicts?.length || 0);
-  if (totalChanges === 0) {
-    console.log(chalk.green('Already in sync. No changes to pull.'));
+async function watchSync(dirPath, palName, opts) {
+  let absolutePath, pal, keyPair;
+  try {
+    absolutePath = validateDir(dirPath);
+    pal = findPal(palName);
+    getIdentity();
+    keyPair = getKeyPair();
+  } catch (err) {
+    console.log(chalk.red(err.message));
+    process.exitCode = 1;
     return;
   }
 
-  console.log(chalk.white(`  Changes to apply:`));
-  if (diff.added.length) console.log(chalk.green(`    + ${diff.added.length} new file(s)`));
-  if (diff.modified.length) console.log(chalk.yellow(`    ~ ${diff.modified.length} modified file(s)`));
-  if (diff.deleted.length) console.log(chalk.red(`    - ${diff.deleted.length} deleted file(s)`));
-  if (conflicts.length) console.log(chalk.magenta(`    ! ${conflicts.length} conflict(s) (both sides changed)`));
+  const options = parseSyncOptions(opts);
+  const palHandle = pal.handle || pal.name;
+  const palId = pal.id || pal.publicKey;
+
+  registerSyncHandlers();
+
+  const pair = addSyncPair(absolutePath, palId, `sync:${palHandle}`);
 
-  const magnet = latest.magnet || null;
+  console.log(chalk.blue(`Watching ${absolutePath} for changes...`));
+  console.log(chalk.gray(`Syncing to ${pal.name}. Press Ctrl+C to stop.`));
+
+  let debounceTimer = null;
+  const debounceMs = 2000;
+  let syncing = false;
 
-  if (magnet) {
-    // P2P sync: download the shared directory via WebTorrent, then apply diff
-    console.log(chalk.blue('Downloading via P2P...'));
+  const triggerSync = async () => {
+    if (syncing) return;
+    syncing = true;
 
     try {
-      const WebTorrent = (await import('webtorrent')).default;
-      const tmpDir = path.join(os.tmpdir(), `pe-sync-${pair.id}-${Date.now()}`);
-      fs.mkdirSync(tmpDir, { recursive: true });
-
-      const client = new WebTorrent();
-      await new Promise((resolve, reject) => {
-        const timeout = setTimeout(() => {
-          client.destroy();
-          reject(new Error('Download timed out after 5 minutes'));
-        }, 5 * 60 * 1000);
-
-        client.add(magnet, { path: tmpDir }, (torrent) => {
-          console.log(chalk.gray(`  Downloading ${torrent.files.length} file(s)...`));
-
-          torrent.on('done', async () => {
-            clearTimeout(timeout);
-            console.log(chalk.green('  Download complete. Applying changes...'));
-
-            // The torrent downloads into tmpDir/<torrent.name>/
-            const sourcePath = path.join(tmpDir, torrent.name);
-            const results = applyDiff(diff, sourcePath, absolutePath);
-
-            if (results.copied.length) {
-              console.log(chalk.green(`  Copied ${results.copied.length} file(s)`));
-            }
-            if (results.deleted.length) {
-              console.log(chalk.red(`  Deleted ${results.deleted.length} file(s)`));
-            }
-            if (results.conflicted.length) {
-              console.log(chalk.magenta(`  ${results.conflicted.length} conflict(s) saved with .sync-conflict suffix`));
-              for (const c of results.conflicted) {
-                console.log(chalk.gray(`    ${c.original} -> ${c.conflictFile}`));
-              }
-            }
-            if (results.errors.length) {
-              console.log(chalk.red(`  ${results.errors.length} error(s):`));
-              for (const e of results.errors) {
-                console.log(chalk.red(`    ${e.file}: ${e.error}`));
-              }
-            }
-
-            const newManifest = await buildManifest(absolutePath, getSyncManifest(pair.id));
-            saveSyncManifest(pair.id, newManifest);
-            updateSyncPair(pair.id, {
-              lastSync: new Date().toISOString(),
-              status: 'synced',
-              lastDirection: 'pull',
-            });
-
-            addSyncHistoryEntry(pair.id, {
-              direction: 'pull',
-              filesAdded: results.copied.length,
-              filesModified: 0,
-              filesDeleted: results.deleted.length,
-              conflicts: results.conflicted.length,
-              totalFiles: newManifest.length,
-            });
-
-            client.destroy();
-            // Clean up temp dir
-            fs.rmSync(tmpDir, { recursive: true, force: true });
-            console.log(chalk.green('Pull complete.'));
-            resolve();
-          });
+      const lastManifest = getSyncManifest(pair.id);
+      const manifest = await buildManifest(absolutePath, lastManifest, options);
 
-          torrent.on('error', (err) => {
-            clearTimeout(timeout);
-            client.destroy();
-            reject(err);
-          });
-        });
+      if (lastManifest) {
+        const lastMap = manifestToMap(lastManifest);
+        const currentMap = manifestToMap(manifest);
+        const diff = diffManifests(lastMap, currentMap);
+        const total = diff.added.length + diff.modified.length + diff.deleted.length;
+        if (total === 0) {
+          syncing = false;
+          return;
+        }
+        console.log(chalk.blue(`Change detected: ${chalk.green(`+${diff.added.length}`)} ${chalk.yellow(`~${diff.modified.length}`)} ${chalk.red(`-${diff.deleted.length}`)}`));
+      } else {
+        console.log(chalk.blue(`Initial sync: ${manifest.length} file(s)`));
+      }
+
+      // Select transport and send via PAL/1.0
+      const transport = await selectSyncTransport(palId, { peerHandle: palHandle });
+      const session = new SyncSession({
+        localPath: absolutePath,
+        peerPK: palId,
+        transport,
+        keyPair,
+        syncPairId: pair.id,
+        options,
       });
-    } catch (err) {
-      logger.error(`P2P sync download failed: ${err.message}`);
-      console.log(chalk.yellow(`P2P download failed: ${err.message}`));
-      console.log(chalk.gray('Saving diff for manual resolution. Use `pe sync status` to review.'));
 
-      saveSyncManifest(pair.id, remoteManifest);
+      await session.start(lastManifest);
+
+      saveSyncManifest(pair.id, manifest);
       updateSyncPair(pair.id, {
         lastSync: new Date().toISOString(),
-        status: 'pending-download',
-        lastDirection: 'pull',
-        pendingDiff: {
-          added: diff.added.length,
-          modified: diff.modified.length,
-          deleted: diff.deleted.length,
-          conflicts: conflicts.length,
-        },
+        status: 'synced',
+        lastDirection: 'push',
+      });
+
+      addSyncHistoryEntry(pair.id, {
+        direction: 'push',
+        totalFiles: manifest.length,
+        auto: true,
       });
+
+      session.finish();
+      console.log(chalk.green(`Synced to ${pal.name} at ${new Date().toLocaleTimeString()}`));
+    } catch (err) {
+      logger.error(`Watch sync failed: ${err.message}`);
+      console.log(chalk.yellow(`Sync failed: ${err.message}`));
+    } finally {
+      syncing = false;
     }
-  } else {
-    // No magnet available — pal needs to share the directory first
-    console.log(chalk.yellow('No magnet link in manifest. Pal must share the directory first.'));
-    console.log(chalk.gray('Ask them to run `pe share <path>` then `pe sync push` again.'));
-    console.log(chalk.gray('Diff summary saved. Use `pe sync status` to review.'));
+  };
 
-    saveSyncManifest(pair.id, remoteManifest);
-    updateSyncPair(pair.id, {
-      lastSync: new Date().toISOString(),
-      status: 'pending-download',
-      lastDirection: 'pull',
-      pendingDiff: {
-        added: diff.added.length,
-        modified: diff.modified.length,
-        deleted: diff.deleted.length,
-        conflicts: conflicts.length,
-      },
+  try {
+    const watcher = fs.watch(absolutePath, { recursive: true }, (_event, filename) => {
+      if (filename && /node_modules|\.git/.test(filename)) return;
+      if (debounceTimer) clearTimeout(debounceTimer);
+      debounceTimer = setTimeout(triggerSync, debounceMs);
     });
+    process.on('SIGINT', () => { watcher.close(); process.exit(0); });
+  } catch (err) {
+    console.log(chalk.red(`Watch failed: ${err.message}`));
+    process.exitCode = 1;
+    return;
   }
+
+  triggerSync();
 }
 
 // --- pe sync status <path> ---
@@ -434,7 +484,7 @@ async function syncStatus(dirPath) {
   if (!dirPath) {
     const pairs = getSyncPairs();
     if (pairs.length === 0) {
-      console.log(chalk.gray('No sync pairs configured. Use `pe sync push <path> <pal>` to start.'));
+      console.log(chalk.gray('No sync pairs configured. Use `pe sync <path> <pal>` to start.'));
       return;
     }
 
@@ -472,7 +522,7 @@ async function syncStatus(dirPath) {
   const pairs = getSyncPairs().filter(p => p.localPath === absolutePath);
   if (pairs.length === 0) {
     console.log(chalk.yellow(`No sync pairs for ${absolutePath}.`));
-    console.log(chalk.gray('Use `pe sync push <path> <pal>` to create one.'));
+    console.log(chalk.gray('Use `pe sync <path> <pal>` to create one.'));
     return;
   }
 
@@ -520,115 +570,21 @@ async function syncStatus(dirPath) {
     if (history.length > 0) {
       console.log(chalk.gray(`    Last ${Math.min(history.length, 3)} syncs:`));
       for (const h of history.slice(0, 3)) {
-        const dir = h.direction === 'push' ? chalk.blue('PUSH') : chalk.magenta('PULL');
+        const dir = h.direction === 'push' ? chalk.blue('PUSH') :
+                    h.direction === 'pull' ? chalk.magenta('PULL') :
+                    chalk.cyan('SYNC');
         const changes = [];
         if (h.filesAdded) changes.push(chalk.green(`+${h.filesAdded}`));
         if (h.filesModified) changes.push(chalk.yellow(`~${h.filesModified}`));
         if (h.filesDeleted) changes.push(chalk.red(`-${h.filesDeleted}`));
         if (h.conflicts) changes.push(chalk.magenta(`!${h.conflicts}`));
-        console.log(chalk.gray(`      ${h.timestamp}  ${dir}  ${changes.join(' ')}`));
+        console.log(chalk.gray(`      ${h.timestamp}  ${dir}  ${changes.join(' ')}${h.auto ? chalk.gray(' [auto]') : ''}`));
       }
     }
     console.log('');
   }
 }
 
-// --- pe sync watch <path> <pal> ---
-
-function watchSync(dirPath, palName) {
-  let absolutePath, pal;
-  try {
-    absolutePath = validateDir(dirPath);
-    pal = findPal(palName);
-  } catch (err) {
-    console.log(chalk.red(err.message));
-    process.exitCode = 1;
-    return;
-  }
-
-  const palHandle = pal.handle || pal.name;
-  const palId = pal.id;
-  const pair = addSyncPair(absolutePath, palId, `sync:${palHandle}`);
-
-  console.log(chalk.blue(`Watching ${absolutePath} for changes...`));
-  console.log(chalk.gray(`Syncing to ${pal.name}. Press Ctrl+C to stop.`));
-
-  let debounceTimer = null;
-  const debounceMs = 2000;
-  let syncing = false;
-
-  const triggerSync = async () => {
-    if (syncing) return;
-    syncing = true;
-
-    try {
-      const lastManifest = getSyncManifest(pair.id);
-      const manifest = await buildManifest(absolutePath, lastManifest);
-
-      if (lastManifest) {
-        const lastMap = manifestToMap(lastManifest);
-        const currentMap = manifestToMap(manifest);
-        const diff = diffManifests(lastMap, currentMap);
-        const total = diff.added.length + diff.modified.length + diff.deleted.length;
-        if (total === 0) {
-          syncing = false;
-          return;
-        }
-        console.log(chalk.blue(`Change detected: ${chalk.green(`+${diff.added.length}`)} ${chalk.yellow(`~${diff.modified.length}`)} ${chalk.red(`-${diff.deleted.length}`)}`));
-      } else {
-        console.log(chalk.blue(`Initial sync: ${manifest.length} file(s)`));
-      }
-
-      // Include magnet if available from existing share
-      const watchShares = config.get('shares') || [];
-      const watchShare = watchShares.find(s => s.path === absolutePath && s.magnet);
-
-      await sendMessage(palHandle, {
-        type: 'sync-manifest',
-        syncPairId: pair.id,
-        manifest,
-        magnet: watchShare?.magnet || null,
-        timestamp: new Date().toISOString(),
-      });
-
-      saveSyncManifest(pair.id, manifest);
-      updateSyncPair(pair.id, {
-        lastSync: new Date().toISOString(),
-        status: 'synced',
-        lastDirection: 'push',
-      });
-
-      addSyncHistoryEntry(pair.id, {
-        direction: 'push',
-        totalFiles: manifest.length,
-        auto: true,
-      });
-
-      console.log(chalk.green(`Synced to ${pal.name} at ${new Date().toLocaleTimeString()}`));
-    } catch (err) {
-      logger.error(`Watch sync failed: ${err.message}`);
-      console.log(chalk.yellow(`Sync failed: ${err.message}`));
-    } finally {
-      syncing = false;
-    }
-  };
-
-  try {
-    const watcher = fs.watch(absolutePath, { recursive: true }, (_event, filename) => {
-      if (filename && /node_modules|\.git/.test(filename)) return;
-      if (debounceTimer) clearTimeout(debounceTimer);
-      debounceTimer = setTimeout(triggerSync, debounceMs);
-    });
-    process.on('SIGINT', () => { watcher.close(); process.exit(0); });
-  } catch (err) {
-    console.log(chalk.red(`Watch failed: ${err.message}`));
-    process.exitCode = 1;
-    return;
-  }
-
-  triggerSync();
-}
-
 // --- pe sync remove <id> ---
 
 function removePair(id) {
@@ -643,6 +599,14 @@ function removePair(id) {
   console.log(chalk.green(`Removed sync pair ${id}.`));
 }
 
+function parseInterval(str) {
+  const match = str.match(/^(\d+)(s|m|h)$/);
+  if (!match) return null;
+  const [, num, unit] = match;
+  const multipliers = { s: 1000, m: 60000, h: 3600000 };
+  return parseInt(num, 10) * multipliers[unit];
+}
+
 function formatSyncBytes(b) {
   if (!b) return '0 B';
   if (b < 1024) return b + ' B';
@@ -656,31 +620,55 @@ function formatSyncBytes(b) {
 export default function syncCommand(program) {
   const cmd = program
     .command('sync')
-    .description('sync directories with pals');
+    .description('sync directories with pals (rsync-like P2P sync)');
+
+  // Default: pe sync <path> <pal> — bi-directional
+  const defaultSync = cmd
+    .command('start <path> <pal>')
+    .description('bi-directional sync with a pal (default)')
+    .action(async (syncPath, pal, cliOpts) => {
+      if (!syncPath?.trim()) {
+        console.log(chalk.red('Error: path cannot be empty.'));
+        process.exitCode = 1;
+        return;
+      }
+      await biSync(syncPath, pal, cliOpts);
+    });
+  addSyncFlagsToCommand(defaultSync);
 
-  cmd
+  const pushCmd = cmd
     .command('push <path> <pal>')
-    .description('push local changes to a pal')
-    .action(async (syncPath, pal) => {
-      if (!syncPath || !syncPath.trim()) {
+    .description('push local changes to a pal (one-way)')
+    .action(async (syncPath, pal, cliOpts) => {
+      if (!syncPath?.trim()) {
         console.log(chalk.red('Error: path cannot be empty.'));
         process.exitCode = 1;
         return;
       }
-      await pushSync(syncPath, pal);
+      await pushSync(syncPath, pal, cliOpts);
     });
+  addSyncFlagsToCommand(pushCmd);
 
-  cmd
+  const pullCmd = cmd
     .command('pull <path> <pal>')
-    .description('pull changes from a pal')
-    .action(async (syncPath, pal) => {
-      if (!syncPath || !syncPath.trim()) {
+    .description('pull changes from a pal (one-way)')
+    .action(async (syncPath, pal, cliOpts) => {
+      if (!syncPath?.trim()) {
         console.log(chalk.red('Error: path cannot be empty.'));
         process.exitCode = 1;
         return;
       }
-      await pullSync(syncPath, pal);
+      await pullSync(syncPath, pal, cliOpts);
+    });
+  addSyncFlagsToCommand(pullCmd);
+
+  const watchCmd = cmd
+    .command('watch <path> <pal>')
+    .description('watch directory and auto-sync on changes')
+    .action(async (syncPath, pal, cliOpts) => {
+      await watchSync(syncPath, pal, cliOpts);
     });
+  addSyncFlagsToCommand(watchCmd);
 
   cmd
     .command('status [path]')
@@ -689,13 +677,6 @@ export default function syncCommand(program) {
       syncStatus(syncPath);
     });
 
-  cmd
-    .command('watch <path> <pal>')
-    .description('watch directory and auto-push on changes')
-    .action((syncPath, pal) => {
-      watchSync(syncPath, pal);
-    });
-
   cmd
     .command('list')
     .description('list all sync pairs')
@@ -743,7 +724,9 @@ export default function syncCommand(program) {
           console.log(chalk.gray('    No history yet.'));
         } else {
           for (const h of history) {
-            const dir = h.direction === 'push' ? chalk.blue('PUSH') : chalk.magenta('PULL');
+            const dir = h.direction === 'push' ? chalk.blue('PUSH') :
+                        h.direction === 'pull' ? chalk.magenta('PULL') :
+                        chalk.cyan('SYNC');
             const changes = [];
             if (h.filesAdded) changes.push(chalk.green(`+${h.filesAdded}`));
             if (h.filesModified) changes.push(chalk.yellow(`~${h.filesModified}`));
@@ -761,7 +744,7 @@ export default function syncCommand(program) {
     .command('diff <localPath> <remotePath>')
     .description('compare local and remote folders, show what needs to transfer')
     .option('--json', 'Output as JSON')
-    .action(async (localPath, remotePath, opts) => {
+    .action(async (localPath, remotePath, cmdOpts) => {
       try {
         console.log(chalk.blue('Building local manifest...'));
         const localManifest = buildDiffManifest(localPath);
@@ -771,7 +754,7 @@ export default function syncCommand(program) {
         const diff = diffFileManifests(localManifest, remoteManifest);
         const summary = diffSummary(diff);
 
-        if (opts.json) {
+        if (cmdOpts.json) {
           console.log(JSON.stringify({ diff, summary }, null, 2));
           return;
         }
@@ -802,26 +785,195 @@ export default function syncCommand(program) {
       }
     });
 
+  // --- pe sync profile save/list/use ---
+  const profileCmd = cmd.command('profile').description('manage sync flag profiles');
+
+  profileCmd
+    .command('save <name>')
+    .description('save current flags as a named profile')
+    .action((name, _opts, profileCommand) => {
+      // Collect flags from parent command context
+      const parentOpts = profileCommand.parent?.parent?.opts() || {};
+      const profiles = config.get('syncProfiles') || {};
+      const profile = {};
+      for (const key of ['exclude', 'include', 'delete', 'checksum', 'sizeOnly', 'update',
+        'ignoreExisting', 'backup', 'compress', 'bandwidthLimit', 'archive']) {
+        if (parentOpts[key] !== undefined) profile[key] = parentOpts[key];
+      }
+      profiles[name] = profile;
+      config.set('syncProfiles', profiles);
+      console.log(chalk.green(`Profile '${name}' saved.`));
+      if (Object.keys(profile).length === 0) {
+        console.log(chalk.gray('  (empty profile — use with sync flags to save them)'));
+      } else {
+        for (const [k, v] of Object.entries(profile)) {
+          console.log(chalk.gray(`  ${k}: ${JSON.stringify(v)}`));
+        }
+      }
+    });
+
+  profileCmd
+    .command('list')
+    .description('list saved profiles')
+    .action(() => {
+      const profiles = config.get('syncProfiles') || {};
+      const names = Object.keys(profiles);
+      if (names.length === 0) {
+        console.log(chalk.gray('No saved profiles. Use `pe sync profile save <name>` to create one.'));
+        return;
+      }
+      console.log('');
+      console.log(chalk.cyan.bold('Sync Profiles'));
+      for (const name of names) {
+        const p = profiles[name];
+        const flags = Object.entries(p).map(([k, v]) => `${k}=${JSON.stringify(v)}`).join(', ');
+        console.log(`  ${chalk.white(name)}: ${chalk.gray(flags || '(empty)')}`);
+      }
+      console.log('');
+    });
+
+  profileCmd
+    .command('use <name>')
+    .description('show flags for a profile (use with eval or copy)')
+    .action((name) => {
+      const profiles = config.get('syncProfiles') || {};
+      const profile = profiles[name];
+      if (!profile) {
+        console.log(chalk.red(`Profile '${name}' not found.`));
+        process.exitCode = 1;
+        return;
+      }
+      const flags = [];
+      if (profile.exclude) {
+        const arr = Array.isArray(profile.exclude) ? profile.exclude : [profile.exclude];
+        arr.forEach(p => flags.push(`--exclude "${p}"`));
+      }
+      if (profile.include) {
+        const arr = Array.isArray(profile.include) ? profile.include : [profile.include];
+        arr.forEach(p => flags.push(`--include "${p}"`));
+      }
+      if (profile.delete) flags.push('--delete');
+      if (profile.checksum) flags.push('--checksum');
+      if (profile.sizeOnly) flags.push('--size-only');
+      if (profile.update) flags.push('--update');
+      if (profile.ignoreExisting) flags.push('--ignore-existing');
+      if (profile.backup) flags.push('--backup');
+      if (profile.compress) flags.push('--compress');
+      if (profile.bandwidthLimit) flags.push(`--bandwidth-limit ${profile.bandwidthLimit}`);
+      if (profile.archive) flags.push('--archive');
+
+      console.log(flags.join(' ') || '(no flags)');
+    });
+
+  profileCmd
+    .command('delete <name>')
+    .description('delete a saved profile')
+    .action((name) => {
+      const profiles = config.get('syncProfiles') || {};
+      if (!profiles[name]) {
+        console.log(chalk.red(`Profile '${name}' not found.`));
+        process.exitCode = 1;
+        return;
+      }
+      delete profiles[name];
+      config.set('syncProfiles', profiles);
+      console.log(chalk.green(`Profile '${name}' deleted.`));
+    });
+
+  // --- pe sync schedule <path> <pal> --every <interval> ---
+  cmd
+    .command('schedule <path> <pal>')
+    .description('background sync at intervals')
+    .requiredOption('--every <interval>', 'sync interval (e.g., 5m, 1h, 30s)')
+    .action(async (syncPath, pal, schedOpts) => {
+      let absolutePath, palObj, keyPair;
+      try {
+        absolutePath = validateDir(syncPath);
+        palObj = findPal(pal);
+        getIdentity();
+        keyPair = getKeyPair();
+      } catch (err) {
+        console.log(chalk.red(err.message));
+        process.exitCode = 1;
+        return;
+      }
+
+      const intervalMs = parseInterval(schedOpts.every);
+      if (!intervalMs || intervalMs < 5000) {
+        console.log(chalk.red('Invalid interval. Minimum: 5s. Examples: 30s, 5m, 1h'));
+        process.exitCode = 1;
+        return;
+      }
+
+      const palHandle = palObj.handle || palObj.name;
+      const palId = palObj.id || palObj.publicKey;
+      const pair = addSyncPair(absolutePath, palId, `sync:${palHandle}`);
+
+      registerSyncHandlers();
+
+      console.log(chalk.blue(`Scheduled sync: ${absolutePath} -> ${palObj.name} every ${schedOpts.every}`));
+      console.log(chalk.gray('Press Ctrl+C to stop.'));
+
+      const doSync = async () => {
+        try {
+          const transport = await selectSyncTransport(palId, { peerHandle: palHandle });
+          const lastManifest = getSyncManifest(pair.id);
+          const session = new SyncSession({
+            localPath: absolutePath,
+            peerPK: palId,
+            transport,
+            keyPair,
+            syncPairId: pair.id,
+          });
+          await session.start(lastManifest);
+          const manifest = session.localManifest;
+          saveSyncManifest(pair.id, manifest);
+          updateSyncPair(pair.id, {
+            lastSync: new Date().toISOString(),
+            status: 'synced',
+            lastDirection: 'push',
+          });
+          addSyncHistoryEntry(pair.id, {
+            direction: 'push',
+            totalFiles: manifest.length,
+            auto: true,
+          });
+          session.finish();
+          console.log(chalk.green(`  Synced at ${new Date().toLocaleTimeString()} (${manifest.length} files)`));
+        } catch (err) {
+          console.log(chalk.yellow(`  Sync failed: ${err.message}`));
+        }
+      };
+
+      doSync();
+      const timer = setInterval(doSync, intervalMs);
+      process.on('SIGINT', () => { clearInterval(timer); process.exit(0); });
+    });
+
   cmd.addHelpText('after', `
 ${chalk.cyan('Examples:')}
-  $ pe sync push ./project alice      Push local changes to alice
-  $ pe sync pull ./project alice      Pull alice's changes locally
-  $ pe sync status ./project          Show what changed since last sync
-  $ pe sync status                    Show all sync pairs
-  $ pe sync watch ./project alice     Watch and auto-push on changes
-  $ pe sync list                      List all sync pairs
-  $ pe sync remove <id>               Remove a sync pair
-  $ pe sync diff ./local ./remote     Compare two folders, show transfer needed
-  $ pe sync history                   View sync history for all pairs
-  $ pe sync history <id>              View sync history for a specific pair
+  $ pe sync start ./project alice       Bi-directional sync with alice
+  $ pe sync push ./project alice        Push local changes to alice
+  $ pe sync pull ./project alice        Pull alice's changes locally
+  $ pe sync watch ./project alice       Watch and auto-sync on changes
+  $ pe sync status ./project            Show what changed since last sync
+  $ pe sync status                      Show all sync pairs
+
+${chalk.cyan('rsync-like flags:')}
+  $ pe sync push ./project alice --dry-run          Preview without applying
+  $ pe sync push ./project alice --exclude "*.log"  Skip log files
+  $ pe sync push ./project alice --delete           Remove files not in source
+  $ pe sync push ./project alice --compress          Compress transfer
+  $ pe sync push ./project alice --progress          Show progress
+  $ pe sync push ./project alice --archive           --recursive --checksum --delete
+  $ pe sync push ./project alice --backup            Create .bak before overwriting
+  $ pe sync push ./project alice --bandwidth-limit 500  Throttle to 500 KB/s
 
 ${chalk.cyan('How it works:')}
-  1. ${chalk.white('push')} scans your directory, computes file hashes, and sends
-     the manifest to your pal via the discovery server.
-  2. ${chalk.white('pull')} checks for manifests from your pal, compares with
-     your local files, and applies changes.
-  3. If both sides modified the same file, a ${chalk.magenta('.sync-conflict')} copy
-     is created so you don't lose either version.
-  4. ${chalk.white('watch')} monitors your directory and auto-pushes on changes.
+  1. Sync uses PAL/1.0 protocol over LAN (TCP:7474) or WebRTC (internet).
+  2. No discovery server required for LAN sync.
+  3. Manifests are signed and encrypted (Ed25519 + XChaCha20-Poly1305).
+  4. Conflicts create ${chalk.magenta('.sync-conflict')} copies — no data loss.
+  5. ${chalk.white('watch')} monitors your directory and auto-syncs on changes.
 `);
 }