@alfe.ai/openclaw-sync 0.3.6 → 0.3.8

package/dist/plugin2.js

@@ -1,10 +1,11 @@
-import { c as loadIgnorePatterns, l as shouldIgnore, n as isRecoveryArtifact, p as readManifest, t as createSyncEngine, u as shouldIgnoreDir } from "./sync-engine.js";
+import { c as loadIgnorePatterns, l as shouldIgnore, n as isRecoveryArtifact, p as readManifest, t as createSyncEngine, u as shouldIgnoreDir, y as validatePrivateRelativePath } from "./sync-engine.js";
 import { createRequire } from "node:module";
-import { mkdir, rm, unlink, writeFile } from "node:fs/promises";
+import { lstat, mkdir, readdir, rm, rmdir, unlink, writeFile } from "node:fs/promises";
 import { existsSync } from "node:fs";
-import { dirname, join, normalize, relative, sep } from "node:path";
+import { dirname, isAbsolute, join, normalize, relative, sep } from "node:path";
+import { createLogger } from "@auriclabs/logger";
 import { watch } from "chokidar";
-import { DEFAULT_SOCKET_PATH, DEFAULT_WORKSPACE_PATH, configExists, resolveConfig } from "@alfe.ai/config";
+import { DEFAULT_SOCKET_PATH, DEFAULT_WORKSPACE_PATH, configExists, deriveServiceWsUrl, resolveConfig } from "@alfe.ai/config";
 import { connectToDaemon, getActivationKey, guardedStart, resetActivation } from "@alfe.ai/openclaw-plugin-kit";
 import { AgentApiClient } from "@alfe.ai/agent-api-client";
 //#region src/watcher.ts
@@ -14,6 +15,8 @@ import { AgentApiClient } from "@alfe.ai/agent-api-client";
 * Uses chokidar to watch the workspace root, debounces per-file changes
 * by 2 seconds, and emits batches of changed paths.
 */
+const WORKSPACE_IGNORE_FILE = ".alfesyncignore";
+const log = createLogger("SyncWatcher");
 /**
 * Start watching a workspace for file changes.
 *
@@ -21,7 +24,8 @@ import { AgentApiClient } from "@alfe.ai/agent-api-client";
 */
 async function startWatcher(options) {
 	const { workspacePath, runtime = "openclaw", debounceMs = 2e3, onChanges } = options;
-	const ignorePatterns = await loadIgnorePatterns(workspacePath, runtime);
+	let ignorePatterns = await loadIgnorePatterns(workspacePath, runtime);
+	let stopped = false;
 	const pending = /* @__PURE__ */ new Map();
 	let batchPaths = /* @__PURE__ */ new Set();
 	let flushTimer = null;
@@ -32,11 +36,12 @@ async function startWatcher(options) {
 			if (batchPaths.size === 0) return;
 			const paths = [...batchPaths];
 			batchPaths = /* @__PURE__ */ new Set();
-			onChanges(paths);
+			Promise.resolve(onChanges(paths)).catch((error) => {
+				log.error({ err: error }, "Sync watcher change handler failed");
+			});
 		}, debounceMs);
 	}
-	function handleChange(absolutePath) {
-		const relativePath = relative(workspacePath, absolutePath).replace(/\\/g, "/");
+	function queueChange(relativePath) {
 		if (shouldIgnore(relativePath, ignorePatterns)) return;
 		const existingTimer = pending.get(relativePath);
 		if (existingTimer) clearTimeout(existingTimer);
@@ -60,16 +65,40 @@ async function startWatcher(options) {
 			return shouldIgnoreDir(rel, ignorePatterns);
 		}
 	});
+	let ignoreReloadTail = Promise.resolve();
+	function handleChange(absolutePath) {
+		const relativePath = relative(workspacePath, absolutePath).replace(/\\/g, "/");
+		if (relativePath === WORKSPACE_IGNORE_FILE) {
+			ignoreReloadTail = ignoreReloadTail.then(async () => {
+				const nextRules = await loadIgnorePatterns(workspacePath, runtime);
+				if (stopped) return;
+				ignorePatterns = nextRules;
+				watcher.unwatch(workspacePath);
+				watcher.add(workspacePath);
+				queueChange(relativePath);
+			}).catch((error) => {
+				log.error({ err: error }, "Failed to reload sync ignore rules");
+			});
+			return;
+		}
+		queueChange(relativePath);
+	}
 	watcher.on("add", handleChange);
 	watcher.on("change", handleChange);
 	watcher.on("unlink", handleChange);
+	watcher.on("error", (error) => {
+		log.error({ err: error }, "Sync watcher failed");
+	});
 	return async () => {
+		stopped = true;
 		for (const timer of pending.values()) clearTimeout(timer);
 		pending.clear();
 		if (flushTimer) {
 			clearTimeout(flushTimer);
 			flushTimer = null;
 		}
+		batchPaths.clear();
+		await ignoreReloadTail;
 		await watcher.close();
 	};
 }
@@ -87,25 +116,56 @@ async function startWatcher(options) {
 * `AgentApiClient.sharedDownloadUrl`).
 */
 const MAX_SHARED_FILE_SIZE = 100 * 1024 * 1024;
+const SHARED_LIST_PAGE_SIZE = 500;
+const MAX_SHARED_LIST_PAGES = 100;
+function validateScope(scope) {
+	const candidate = scope;
+	if (candidate === null || candidate.scopeType !== "org" && candidate.scopeType !== "team" && candidate.scopeType !== "project" || typeof candidate.scopeId !== "string" || candidate.scopeId.length === 0 || candidate.scopeId.length > 512 || candidate.scopeId === "." || candidate.scopeId === ".." || candidate.scopeId.includes("/") || candidate.scopeId.includes("\\") || candidate.scopeId.includes("\0") || typeof candidate.name !== "string" || candidate.name.length > 512) throw new Error("Invalid shared sync scope");
+	return candidate;
+}
+function validateSharedFilePath(filePath) {
+	if (filePath.length === 0 || filePath.length > 1024 || isAbsolute(filePath) || filePath.includes("\\") || filePath.includes("\0")) throw new Error("Invalid shared sync file path");
+	const segments = filePath.split("/");
+	if (segments.some((segment) => segment === "" || segment === "." || segment === "..")) throw new Error("Invalid shared sync file path");
+	return segments.join("/");
+}
 /** Throw if `resolvedPath` would escape `baseDir`. */
 function assertContained(baseDir, resolvedPath) {
 	const normalizedBase = normalize(baseDir) + sep;
 	const normalizedPath = normalize(resolvedPath);
 	if (!normalizedPath.startsWith(normalizedBase) && normalizedPath !== normalize(baseDir)) throw new Error(`Path traversal blocked: ${resolvedPath} escapes ${baseDir}`);
 }
+async function assertNoSymlinkTraversal(baseDir, relativePath) {
+	const canonical = validateSharedFilePath(relativePath);
+	const resolvedPath = join(baseDir, canonical);
+	assertContained(baseDir, resolvedPath);
+	let current = normalize(baseDir);
+	for (const segment of canonical.split("/")) {
+		current = join(current, segment);
+		try {
+			if ((await lstat(current)).isSymbolicLink()) throw new Error("Shared sync path crosses a symbolic link");
+		} catch (error) {
+			if (error instanceof Error && "code" in error && error.code === "ENOENT") break;
+			throw error;
+		}
+	}
+	return resolvedPath;
+}
 function createSharedSyncEngine(config, log) {
 	let activeScopes = [];
 	const sharedDir = join(config.workspacePath, "shared");
 	function scopeDir(scope) {
+		validateScope(scope);
 		if (scope.scopeType === "org") return join(sharedDir, "org");
 		return join(sharedDir, scope.scopeType === "team" ? "teams" : "projects", scope.scopeId);
 	}
 	async function downloadFile(scope, filePath, localPath) {
-		assertContained(scopeDir(scope), localPath);
+		const canonicalPath = validateSharedFilePath(filePath);
+		if (await assertNoSymlinkTraversal(scopeDir(scope), canonicalPath) !== normalize(localPath)) throw new Error("Shared sync local path does not match its canonical path");
 		const { downloadUrl } = await config.client.sharedDownloadUrl({
 			scope: scope.scopeType,
 			scopeId: scope.scopeId,
-			filePath
+			filePath: canonicalPath
 		});
 		const response = await fetch(downloadUrl);
 		if (!response.ok) throw new Error(`Download failed: HTTP ${String(response.status)}`);
@@ -116,66 +176,147 @@ function createSharedSyncEngine(config, log) {
 		await mkdir(dirname(localPath), { recursive: true });
 		await writeFile(localPath, buffer);
 	}
-	async function syncScope(scope) {
-		const dir = scopeDir(scope);
-		await mkdir(dir, { recursive: true });
-		try {
-			const { files } = await config.client.sharedListFiles({
+	async function listRemoteFiles(scope) {
+		const files = /* @__PURE__ */ new Map();
+		const seenCursors = /* @__PURE__ */ new Set();
+		let cursor;
+		for (let page = 0; page < MAX_SHARED_LIST_PAGES; page++) {
+			const response = await config.client.sharedListFiles({
 				scope: scope.scopeType,
-				scopeId: scope.scopeId
+				scopeId: scope.scopeId,
+				limit: SHARED_LIST_PAGE_SIZE,
+				...cursor ? { cursor } : {}
 			});
-			for (const file of files) {
-				const localPath = join(dir, file.filePath);
+			for (const file of response.files) {
+				const filePath = validateSharedFilePath(file.filePath);
+				files.set(filePath, {
+					...file,
+					filePath
+				});
+			}
+			if (!response.nextCursor) {
+				const paths = new Set(files.keys());
+				for (const filePath of paths) {
+					const segments = filePath.split("/");
+					for (let index = 1; index < segments.length; index++) if (paths.has(segments.slice(0, index).join("/"))) throw new Error("Shared file listing contains a file/directory collision");
+				}
+				return [...files.values()];
+			}
+			if (seenCursors.has(response.nextCursor)) throw new Error("Shared file listing returned a repeated cursor");
+			seenCursors.add(response.nextCursor);
+			cursor = response.nextCursor;
+		}
+		throw new Error(`Shared file listing exceeded ${String(MAX_SHARED_LIST_PAGES)} pages`);
+	}
+	async function pruneLocalMirror(dir, remotePaths) {
+		const remoteDirectories = /* @__PURE__ */ new Set();
+		for (const filePath of remotePaths) {
+			const segments = filePath.split("/");
+			for (let index = 1; index < segments.length; index++) remoteDirectories.add(segments.slice(0, index).join("/"));
+		}
+		const walk = async (currentDir, prefix) => {
+			const entries = await readdir(currentDir, { withFileTypes: true });
+			for (const entry of entries) {
+				const relativePath = prefix ? `${prefix}/${entry.name}` : entry.name;
+				const fullPath = join(currentDir, entry.name);
+				let canonicalPath = null;
 				try {
-					await downloadFile(scope, file.filePath, localPath);
-					log.debug(`Shared sync: downloaded ${scope.scopeType}/${scope.scopeId}/${file.filePath}`);
-				} catch (err) {
-					log.error(`Shared sync: failed to download ${file.filePath}: ${err instanceof Error ? err.message : String(err)}`);
+					canonicalPath = validateSharedFilePath(relativePath);
+				} catch {}
+				if (entry.isSymbolicLink()) {
+					await unlink(fullPath);
+					log.warn(`Shared sync: removed symbolic link ${relativePath}`);
+					continue;
+				}
+				if (entry.isDirectory()) {
+					if (!canonicalPath) {
+						await rm(fullPath, {
+							recursive: true,
+							force: true
+						});
+						continue;
+					}
+					await walk(fullPath, canonicalPath);
+					if (!remoteDirectories.has(canonicalPath)) try {
+						await rmdir(fullPath);
+					} catch (error) {
+						if (!(error instanceof Error && "code" in error && (error.code === "ENOENT" || error.code === "ENOTEMPTY"))) throw error;
+					}
+					continue;
+				}
+				if (!canonicalPath || !remotePaths.has(canonicalPath)) {
+					await unlink(fullPath);
+					log.debug(`Shared sync: pruned stale local file ${relativePath}`);
 				}
 			}
+		};
+		await walk(dir, "");
+	}
+	async function syncScope(scope) {
+		const dir = scopeDir(scope);
+		await mkdir(dir, { recursive: true });
+		const files = await listRemoteFiles(scope);
+		await pruneLocalMirror(dir, new Set(files.map((file) => file.filePath)));
+		for (const file of files) try {
+			const filePath = validateSharedFilePath(file.filePath);
+			await downloadFile(scope, filePath, join(dir, filePath));
+			log.debug(`Shared sync: downloaded ${scope.scopeType}/${scope.scopeId}/${file.filePath}`);
 		} catch (err) {
-			log.error(`Shared sync: failed to list files for ${scope.scopeType}/${scope.scopeId}: ${err instanceof Error ? err.message : String(err)}`);
+			log.error(`Shared sync: failed to download ${file.filePath}: ${err instanceof Error ? err.message : String(err)}`);
 		}
 	}
 	function parseScopedPath(filePath) {
-		if (filePath.includes("..")) return null;
+		if (filePath.length > 2048 || filePath.includes("\\") || filePath.includes("\0")) return null;
 		const orgMatch = /^shared\/org\/(.+)$/.exec(filePath);
 		if (orgMatch) {
 			const scope = activeScopes.find((s) => s.scopeType === "org");
-			if (scope) return {
-				scope,
-				relativePath: orgMatch[1]
-			};
+			if (scope) try {
+				return {
+					scope,
+					relativePath: validateSharedFilePath(orgMatch[1])
+				};
+			} catch {
+				return null;
+			}
 		}
 		const teamMatch = /^shared\/teams\/([^/]+)\/(.+)$/.exec(filePath);
 		if (teamMatch) {
 			const scope = activeScopes.find((s) => s.scopeType === "team" && s.scopeId === teamMatch[1]);
-			if (scope) return {
-				scope,
-				relativePath: teamMatch[2]
-			};
+			if (scope) try {
+				return {
+					scope,
+					relativePath: validateSharedFilePath(teamMatch[2])
+				};
+			} catch {
+				return null;
+			}
 		}
 		const projectMatch = /^shared\/projects\/([^/]+)\/(.+)$/.exec(filePath);
 		if (projectMatch) {
 			const scope = activeScopes.find((s) => s.scopeType === "project" && s.scopeId === projectMatch[1]);
-			if (scope) return {
-				scope,
-				relativePath: projectMatch[2]
-			};
+			if (scope) try {
+				return {
+					scope,
+					relativePath: validateSharedFilePath(projectMatch[2])
+				};
+			} catch {
+				return null;
+			}
 		}
 		return null;
 	}
 	return {
 		async initialize(scopes) {
-			activeScopes = [...scopes];
+			activeScopes = scopes.map(validateScope);
 			log.info(`Shared sync: initializing with ${String(scopes.length)} scope(s)`);
 			await mkdir(sharedDir, { recursive: true });
 			for (const scope of scopes) await syncScope(scope);
 			log.info("Shared sync: initialization complete");
 		},
 		async updateScopes(newScopes) {
+			const validatedScopes = newScopes.map(validateScope);
 			const oldIds = new Set(activeScopes.map((s) => `${s.scopeType}:${s.scopeId}`));
-			const newIds = new Set(newScopes.map((s) => `${s.scopeType}:${s.scopeId}`));
+			const newIds = new Set(validatedScopes.map((s) => `${s.scopeType}:${s.scopeId}`));
 			for (const scope of activeScopes) {
 				const key = `${scope.scopeType}:${scope.scopeId}`;
 				if (!newIds.has(key)) {
@@ -191,14 +332,14 @@ function createSharedSyncEngine(config, log) {
 					}
 				}
 			}
-			for (const scope of newScopes) {
+			for (const scope of validatedScopes) {
 				const key = `${scope.scopeType}:${scope.scopeId}`;
 				if (!oldIds.has(key)) {
 					log.info(`Shared sync: new scope ${scope.scopeType}/${scope.scopeId} — syncing files`);
 					await syncScope(scope);
 				}
 			}
-			activeScopes = [...newScopes];
+			activeScopes = [...validatedScopes];
 		},
 		async handleNotification(filePath, eventType) {
 			const parsed = parseScopedPath(filePath);
@@ -206,11 +347,8 @@ function createSharedSyncEngine(config, log) {
 				log.debug(`Shared sync: ignoring notification for unknown path: ${filePath}`);
 				return;
 			}
-			const dir = scopeDir(parsed.scope);
-			const localPath = join(dir, parsed.relativePath);
-			try {
-				assertContained(dir, localPath);
-			} catch {
+			const localPath = await assertNoSymlinkTraversal(scopeDir(parsed.scope), parsed.relativePath).catch(() => null);
+			if (!localPath) {
 				log.warn(`Shared sync: path traversal blocked for ${filePath}`);
 				return;
 			}
@@ -306,6 +444,9 @@ const SYNC_ACTIVATION_KEY = getActivationKey("sync");
 const SYNC_RELAY_RECONNECT_BASE_MS = 1e3;
 const SYNC_RELAY_RECONNECT_MAX_MS = 3e4;
 const SYNC_RELAY_DEBOUNCE_MS = 500;
+const SYNC_RELAY_MAX_MESSAGE_BYTES = 64 * 1024;
+const SYNC_RELAY_HANDSHAKE_TIMEOUT_MS = 1e4;
+const REMOTE_DELETE_SUPPRESSION_MS = 3e4;
 let client = null;
 let agentId = null;
 let syncEngine = null;
@@ -320,7 +461,119 @@ let syncRelayWs = null;
 let syncRelayReconnectTimer = null;
 let syncRelayReconnectAttempt = 0;
 let syncRelayDebounceTimer = null;
+let syncRelayGeneration = 0;
+let syncRelayActive = false;
+let syncOperationTail = Promise.resolve();
 const syncRelayPendingPaths = /* @__PURE__ */ new Map();
+const remoteDeleteSuppressions = /* @__PURE__ */ new Map();
+function enqueueSyncOperation(operation) {
+	const result = syncOperationTail.then(operation, operation);
+	syncOperationTail = result.then(() => void 0, () => void 0);
+	return result;
+}
+function parseRelayMessage(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
+	const candidate = value;
+	if (candidate.type === "PING") return { type: "PING" };
+	if (candidate.type === "SUBSCRIBE_ACK" && (candidate.status === "ok" || candidate.status === "error") && typeof candidate.agentId === "string" && candidate.agentId.length > 0 && candidate.agentId.length <= 512 && (candidate.message === void 0 || typeof candidate.message === "string" && candidate.message.length <= 1024)) return {
+		type: "SUBSCRIBE_ACK",
+		status: candidate.status,
+		agentId: candidate.agentId,
+		...typeof candidate.message === "string" ? { message: candidate.message } : {}
+	};
+	if (candidate.type === "FILE_CHANGED" && typeof candidate.agentId === "string" && candidate.agentId.length > 0 && candidate.agentId.length <= 512 && typeof candidate.filePath === "string" && (candidate.eventType === "created" || candidate.eventType === "deleted") && (candidate.etag === void 0 || typeof candidate.etag === "string" && candidate.etag.length <= 256)) try {
+		const sharedSegments = candidate.filePath.split("/");
+		const isCanonicalSharedPath = sharedSegments[0] === "shared" && sharedSegments.length >= 3 && !sharedSegments.some((segment) => segment === "" || segment === "." || segment === "..");
+		const filePath = isCanonicalSharedPath ? candidate.filePath : validatePrivateRelativePath(candidate.filePath);
+		if (filePath.length > 1024 || filePath.includes("\0") || filePath.includes("\\") || (filePath === "shared" || filePath.startsWith("shared/")) && !isCanonicalSharedPath) return null;
+		return {
+			type: "FILE_CHANGED",
+			agentId: candidate.agentId,
+			filePath,
+			eventType: candidate.eventType,
+			...typeof candidate.etag === "string" ? { etag: candidate.etag } : {}
+		};
+	} catch {
+		return null;
+	}
+	return null;
+}
+function parseSharedScopes(value) {
+	if (!Array.isArray(value) || value.length > 1e3) return null;
+	const scopes = [];
+	for (const item of value) {
+		if (typeof item !== "object" || item === null || Array.isArray(item)) return null;
+		const candidate = item;
+		if (candidate.scopeType !== "org" && candidate.scopeType !== "team" && candidate.scopeType !== "project" || typeof candidate.scopeId !== "string" || candidate.scopeId.length === 0 || candidate.scopeId.length > 512 || candidate.scopeId === "." || candidate.scopeId === ".." || candidate.scopeId.includes("/") || candidate.scopeId.includes("\\") || candidate.scopeId.includes("\0") || typeof candidate.name !== "string" || candidate.name.length > 512) return null;
+		scopes.push({
+			scopeType: candidate.scopeType,
+			scopeId: candidate.scopeId,
+			name: candidate.name
+		});
+	}
+	return scopes;
+}
+async function runFullSync(engine, log, label) {
+	return enqueueSyncOperation(async () => {
+		if (syncEngine !== engine) return null;
+		try {
+			const result = await engine.fullSync({ quiet: true });
+			lastSyncResult = result;
+			log.info(`${label} complete: ${String(result.pushed)} pushed, ${String(result.pulled)} pulled`);
+			return result;
+		} catch (err) {
+			log.error(`${label} failed: ${err instanceof Error ? err.message : String(err)}`);
+			return null;
+		}
+	});
+}
+async function handleRealtimeChanges(paths, workspacePath, log) {
+	const engine = syncEngine;
+	const brake = deleteBrake;
+	if (!engine || !brake) return;
+	await enqueueSyncOperation(async () => {
+		if (syncEngine !== engine || deleteBrake !== brake) return;
+		const existing = [];
+		const missing = [];
+		const now = Date.now();
+		for (const [suppressedPath, expiresAt] of remoteDeleteSuppressions) if (expiresAt <= now) remoteDeleteSuppressions.delete(suppressedPath);
+		for (const candidate of paths) {
+			let path;
+			try {
+				path = validatePrivateRelativePath(candidate);
+			} catch {
+				log.warn("Realtime sync ignored an invalid workspace path");
+				continue;
+			}
+			if (existsSync(join(workspacePath, path))) {
+				remoteDeleteSuppressions.delete(path);
+				existing.push(path);
+			} else if ((remoteDeleteSuppressions.get(path) ?? 0) > now) remoteDeleteSuppressions.delete(path);
+			else missing.push(path);
+		}
+		log.debug(`Realtime sync: ${String(existing.length)} upload(s), ${String(missing.length)} delete(s)`);
+		if (existing.length > 0) try {
+			lastSyncResult = await engine.push(existing, { quiet: true });
+		} catch (err) {
+			log.error(`Realtime push failed: ${err instanceof Error ? err.message : String(err)}`);
+		}
+		if (missing.length === 0) return;
+		const artifactDeletes = missing.filter((path) => isRecoveryArtifact(path));
+		const regularDeletes = missing.filter((path) => !isRecoveryArtifact(path));
+		const manifest = await readManifest(workspacePath);
+		const manifestSize = Object.keys(manifest.files).length;
+		let toDelete = missing;
+		if (!brake.check(regularDeletes.length, manifestSize)) {
+			log.error(`Sync delete brake tripped: ${String(brake.windowSum() + regularDeletes.length)} deletes in last 60s vs manifest size ${String(manifestSize)} (threshold 30%). Refusing batch — investigate the workspace state.`);
+			toDelete = artifactDeletes;
+		}
+		if (toDelete.length > 0) try {
+			lastSyncResult = await engine.pushDeletes(toDelete, { quiet: true });
+		} catch (err) {
+			log.error(`Realtime delete failed: ${err instanceof Error ? err.message : String(err)}`);
+		}
+	});
+}
 const SCHEDULE_INTERVALS_MS = {
 	hourly: 3600 * 1e3,
 	daily: 1440 * 60 * 1e3,
@@ -348,45 +601,30 @@ function setupSchedule(schedule, log) {
 	scheduledInterval = setInterval(() => {
 		if (!syncEngine) return;
 		const engine = syncEngine;
-		(async () => {
-			try {
-				log.info(`Scheduled sync (${schedule}) starting...`);
-				lastSyncResult = await engine.fullSync({ quiet: true });
-				log.info(`Scheduled sync complete: ${String(lastSyncResult.pushed)} pushed, ${String(lastSyncResult.pulled)} pulled`);
-			} catch (err) {
-				log.error(`Scheduled sync failed: ${err instanceof Error ? err.message : String(err)}`);
-			}
-		})();
+		log.info(`Scheduled sync (${schedule}) starting...`);
+		runFullSync(engine, log, "Scheduled sync");
 	}, intervalMs);
 	scheduledInterval.unref();
 }
 function handleDaemonMessage(msg, log) {
 	if (msg.type === "SYNC_NOW" || msg.command === "SYNC_NOW") {
 		log.info("Received SYNC_NOW command — triggering immediate sync...");
-		if (syncEngine) {
-			const engine = syncEngine;
-			(async () => {
-				try {
-					lastSyncResult = await engine.fullSync({ quiet: true });
-					log.info(`SYNC_NOW complete: ${String(lastSyncResult.pushed)} pushed, ${String(lastSyncResult.pulled)} pulled`);
-				} catch (err) {
-					log.error(`SYNC_NOW failed: ${err instanceof Error ? err.message : String(err)}`);
-				}
-			})();
-		}
+		if (syncEngine) runFullSync(syncEngine, log, "SYNC_NOW");
 	}
 	if (msg.type === "SHARED_SCOPES") {
-		const scopes = msg.scopes;
+		const scopes = parseSharedScopes(msg.scopes);
 		const engine = sharedSyncEngine;
-		if (scopes && engine) {
+		if (!scopes) log.warn("Ignored invalid SHARED_SCOPES payload from daemon");
+		else if (engine) {
 			log.info(`Received SHARED_SCOPES update: ${String(scopes.length)} scope(s)`);
-			(async () => {
+			enqueueSyncOperation(async () => {
+				if (sharedSyncEngine !== engine) return;
 				try {
 					await engine.updateScopes(scopes);
 				} catch (err) {
 					log.error(`SHARED_SCOPES update failed: ${err instanceof Error ? err.message : String(err)}`);
 				}
-			})();
+			});
 		}
 	}
 }
@@ -422,6 +660,7 @@ async function processPendingNotifications(log) {
 		for (const [filePath, info] of privateEntries) if (info.eventType === "deleted") toDelete.push(filePath);
 		else toPull.push(filePath);
 		for (const filePath of toDelete) try {
+			remoteDeleteSuppressions.set(filePath, Date.now() + REMOTE_DELETE_SUPPRESSION_MS);
 			await engine.removeLocalFile(filePath, { quiet: true });
 			log.debug(`Sync relay: deleted ${filePath}`);
 		} catch (err) {
@@ -436,11 +675,20 @@ async function processPendingNotifications(log) {
 		}
 	}
 }
-async function connectToSyncRelay(relayUrl, token, agentIdForSubscribe, log) {
+async function connectToSyncRelay(relayUrl, token, agentIdForSubscribe, log, generation) {
 	try {
 		const { default: WebSocket } = await import("ws");
-		const ws = new WebSocket(`${relayUrl}?token=${encodeURIComponent(token)}`);
+		if (!syncRelayActive || generation !== syncRelayGeneration) return null;
+		const ws = new WebSocket(relayUrl, {
+			headers: { Authorization: `Bearer ${token}` },
+			handshakeTimeout: SYNC_RELAY_HANDSHAKE_TIMEOUT_MS,
+			maxPayload: SYNC_RELAY_MAX_MESSAGE_BYTES
+		});
 		ws.on("open", () => {
+			if (!syncRelayActive || generation !== syncRelayGeneration) {
+				ws.close(1e3, "Stale sync relay connection");
+				return;
+			}
 			log.info("Connected to Sync Relay");
 			syncRelayReconnectAttempt = 0;
 			ws.send(JSON.stringify({
@@ -449,34 +697,47 @@ async function connectToSyncRelay(relayUrl, token, agentIdForSubscribe, log) {
 			}));
 		});
 		ws.on("message", (data) => {
-			let message;
+			if (!syncRelayActive || generation !== syncRelayGeneration) return;
+			const raw = data.toString();
+			if (Buffer.byteLength(raw) > SYNC_RELAY_MAX_MESSAGE_BYTES) {
+				ws.close(1009, "Sync relay message too large");
+				return;
+			}
+			let value;
 			try {
-				message = JSON.parse(data.toString());
+				value = JSON.parse(raw);
 			} catch {
 				return;
 			}
+			const message = parseRelayMessage(value);
+			if (!message) return;
 			switch (message.type) {
 				case "SUBSCRIBE_ACK":
+					if (message.agentId !== agentIdForSubscribe) return;
 					if (message.status === "ok") {
-						log.info(`Subscribed to sync notifications for agent ${message.agentId ?? agentIdForSubscribe}`);
+						log.info(`Subscribed to sync notifications for agent ${message.agentId}`);
 						const sharedEngine = sharedSyncEngine;
-						if (sharedEngine) (async () => {
+						if (sharedEngine) enqueueSyncOperation(async () => {
+							if (sharedSyncEngine !== sharedEngine) return;
 							try {
 								await sharedEngine.fullSync();
 								log.info("Shared sync: reconnect full sync complete");
 							} catch (err) {
 								log.error(`Shared sync: reconnect full sync failed: ${err instanceof Error ? err.message : String(err)}`);
 							}
-						})();
+						});
 					} else log.warn(`Sync relay subscribe failed: ${message.message ?? "unknown"}`);
 					break;
 				case "FILE_CHANGED":
-					if (message.filePath) syncRelayPendingPaths.set(message.filePath, {
+					if (message.agentId !== agentIdForSubscribe) return;
+					syncRelayPendingPaths.set(message.filePath, {
 						etag: message.etag,
-						eventType: message.eventType === "deleted" ? "deleted" : "created"
+						eventType: message.eventType
 					});
 					clearSyncRelayDebounce();
-					syncRelayDebounceTimer = setTimeout(() => void processPendingNotifications(log), SYNC_RELAY_DEBOUNCE_MS);
+					syncRelayDebounceTimer = setTimeout(() => {
+						enqueueSyncOperation(() => processPendingNotifications(log));
+					}, SYNC_RELAY_DEBOUNCE_MS);
 					syncRelayDebounceTimer.unref();
 					break;
 				case "PING":
@@ -487,9 +748,10 @@ async function connectToSyncRelay(relayUrl, token, agentIdForSubscribe, log) {
 			}
 		});
 		ws.on("close", (code) => {
+			if (syncRelayWs === ws) syncRelayWs = null;
+			if (!syncRelayActive || generation !== syncRelayGeneration) return;
 			log.info(`Sync Relay disconnected (code=${String(code)})`);
-			syncRelayWs = null;
-			scheduleSyncRelayReconnect(relayUrl, token, agentIdForSubscribe, log);
+			scheduleSyncRelayReconnect(relayUrl, token, agentIdForSubscribe, log, generation);
 		});
 		ws.on("error", (err) => {
 			log.debug(`Sync Relay error: ${err.message}`);
@@ -497,40 +759,43 @@ async function connectToSyncRelay(relayUrl, token, agentIdForSubscribe, log) {
 		return ws;
 	} catch (err) {
 		log.debug(`Failed to connect to Sync Relay: ${err instanceof Error ? err.message : String(err)}`);
-		scheduleSyncRelayReconnect(relayUrl, token, agentIdForSubscribe, log);
+		if (syncRelayActive && generation === syncRelayGeneration) scheduleSyncRelayReconnect(relayUrl, token, agentIdForSubscribe, log, generation);
 		return null;
 	}
 }
-function scheduleSyncRelayReconnect(relayUrl, token, agentIdForSubscribe, log) {
+function scheduleSyncRelayReconnect(relayUrl, token, agentIdForSubscribe, log, generation) {
+	if (!syncRelayActive || generation !== syncRelayGeneration) return;
 	clearSyncRelayReconnect();
 	const delay = Math.min(SYNC_RELAY_RECONNECT_BASE_MS * Math.pow(2, syncRelayReconnectAttempt), SYNC_RELAY_RECONNECT_MAX_MS);
 	syncRelayReconnectAttempt++;
 	log.debug(`Reconnecting to Sync Relay in ${String(delay)}ms (attempt ${String(syncRelayReconnectAttempt)})`);
 	syncRelayReconnectTimer = setTimeout(() => {
 		(async () => {
-			syncRelayWs = await connectToSyncRelay(relayUrl, token, agentIdForSubscribe, log);
+			const socket = await connectToSyncRelay(relayUrl, token, agentIdForSubscribe, log, generation);
+			if (syncRelayActive && generation === syncRelayGeneration) syncRelayWs = socket;
+			else if (socket) socket.close(1e3, "Stale sync relay connection");
 		})();
 	}, delay);
 	syncRelayReconnectTimer.unref();
 }
 function disconnectSyncRelay() {
+	syncRelayActive = false;
+	syncRelayGeneration++;
 	clearSyncRelayReconnect();
 	clearSyncRelayDebounce();
 	syncRelayPendingPaths.clear();
+	remoteDeleteSuppressions.clear();
 	if (syncRelayWs) {
 		try {
-			syncRelayWs.send(JSON.stringify({ type: "UNSUBSCRIBE" }));
+			if (agentId) syncRelayWs.send(JSON.stringify({
+				type: "UNSUBSCRIBE",
+				agentId
+			}));
 			syncRelayWs.close(1e3, "Plugin deactivating");
 		} catch {}
 		syncRelayWs = null;
 	}
 }
-function deriveRelayUrl(apiUrl) {
-	if (apiUrl.includes("dev.alfe.ai")) return "wss://sync.dev.alfe.ai/ws";
-	if (apiUrl.includes("demo.alfe.ai")) return "wss://sync.demo.alfe.ai/ws";
-	if (apiUrl.includes("test.alfe.ai")) return "wss://sync.test.alfe.ai/ws";
-	return "wss://sync.alfe.ai/ws";
-}
 const plugin = {
 	id: "@alfe.ai/openclaw-sync",
 	name: "Alfe Sync Plugin",
@@ -546,17 +811,11 @@ const plugin = {
 		} catch {}
 		const workspacePath = pluginConfig.workspacePath ?? alfeConfig?.workspacePath ?? DEFAULT_WORKSPACE_PATH;
 		const runtime = alfeConfig?.runtime ?? "openclaw";
-		const syncScope = pluginConfig.syncScope ?? [
-			"config",
-			"conversations",
-			"memory"
-		];
 		const syncSchedule = pluginConfig.syncSchedule ?? "realtime";
 		const socketPath = pluginConfig.socketPath ?? alfeConfig?.socketPath ?? DEFAULT_SOCKET_PATH;
 		const startSyncService = () => {
 			guardedStart(SYNC_ACTIVATION_KEY, log, async () => {
 				log.info("Alfe Sync plugin activating...");
-				log.info(`Sync scope: ${syncScope.join(", ")}`);
 				log.info(`Sync schedule: ${syncSchedule}`);
 				log.info(`Workspace: ${workspacePath}`);
 				if (!configExists()) {
@@ -590,8 +849,12 @@ const plugin = {
 					} catch (err) {
 						log.warn(`Initial workspace reconcile failed: ${err instanceof Error ? err.message : String(err)}`);
 					}
-					syncEngine.pruneIgnored({ quiet: true }).then((pruned) => {
-						if (pruned.pushed > 0) log.info(`Pruned ${String(pruned.pushed)} ignored file(s) from cloud`);
+					const engineForPrune = syncEngine;
+					enqueueSyncOperation(async () => {
+						if (syncEngine !== engineForPrune) return null;
+						return engineForPrune.pruneIgnored({ quiet: true });
+					}).then((pruned) => {
+						if (pruned && pruned.pushed > 0) log.info(`Pruned ${String(pruned.pushed)} ignored file(s) from cloud`);
 					}).catch((err) => {
 						log.warn(`Ignored-file prune failed: ${err instanceof Error ? err.message : String(err)}`);
 					});
@@ -601,35 +864,7 @@ const plugin = {
 							workspacePath,
 							runtime,
 							debounceMs: 2e3,
-							onChanges: async (paths) => {
-								if (!syncEngine) return;
-								const existing = [];
-								const missing = [];
-								for (const p of paths) if (existsSync(join(workspacePath, p))) existing.push(p);
-								else missing.push(p);
-								log.debug(`Realtime sync: ${String(existing.length)} upload(s), ${String(missing.length)} delete(s)`);
-								if (existing.length > 0) try {
-									lastSyncResult = await syncEngine.push(existing, { quiet: true });
-								} catch (err) {
-									log.error(`Realtime push failed: ${err instanceof Error ? err.message : String(err)}`);
-								}
-								if (missing.length > 0) {
-									const artifactDeletes = missing.filter((p) => isRecoveryArtifact(p));
-									const regularDeletes = missing.filter((p) => !isRecoveryArtifact(p));
-									const manifest = await readManifest(workspacePath);
-									const manifestSize = Object.keys(manifest.files).length;
-									let toDelete = missing;
-									if (deleteBrake && !deleteBrake.check(regularDeletes.length, manifestSize)) {
-										log.error(`Sync delete brake tripped: ${String(deleteBrake.windowSum() + regularDeletes.length)} deletes in last 60s vs manifest size ${String(manifestSize)} (threshold 30%). Refusing batch — investigate the workspace state.`);
-										toDelete = artifactDeletes;
-									}
-									if (toDelete.length > 0) try {
-										lastSyncResult = await syncEngine.pushDeletes(toDelete, { quiet: true });
-									} catch (err) {
-										log.error(`Realtime delete failed: ${err instanceof Error ? err.message : String(err)}`);
-									}
-								}
-							}
+							onChanges: (paths) => handleRealtimeChanges(paths, workspacePath, log)
 						});
 						log.info("File watcher started for realtime sync");
 					} catch (err) {
@@ -652,11 +887,6 @@ const plugin = {
 					log.warn(`Sync register failed: ${err instanceof Error ? err.message : String(err)}`);
 				}
 				if (registered) {
-					try {
-						syncRelayWs = await connectToSyncRelay(pluginConfig.syncRelayUrl ?? deriveRelayUrl(syncCfg.apiUrl), syncCfg.apiKey, registered.agentId, log);
-					} catch (err) {
-						log.debug(`Sync Relay connection skipped: ${err instanceof Error ? err.message : String(err)}`);
-					}
 					if (pluginConfig.sharedSync !== false) try {
 						sharedSyncEngine = createSharedSyncEngine({
 							workspacePath,
@@ -666,12 +896,21 @@ const plugin = {
 					} catch (err) {
 						log.debug(`Shared sync engine skipped: ${err instanceof Error ? err.message : String(err)}`);
 					}
+					try {
+						const relayUrl = pluginConfig.syncRelayUrl ?? deriveServiceWsUrl(syncCfg.apiUrl, "sync");
+						syncRelayActive = true;
+						const relayGeneration = ++syncRelayGeneration;
+						syncRelayWs = await connectToSyncRelay(relayUrl, syncCfg.apiKey, registered.agentId, log, relayGeneration);
+					} catch (err) {
+						log.debug(`Sync Relay connection skipped: ${err instanceof Error ? err.message : String(err)}`);
+					}
 				}
 			});
 		};
 		const stopSyncService = async () => {
 			clearSchedule();
 			disconnectSyncRelay();
+			deleteBrake = null;
 			if (stopWatcher) {
 				try {
 					await stopWatcher();
@@ -681,7 +920,6 @@ const plugin = {
 				}
 				stopWatcher = null;
 			}
-			deleteBrake = null;
 			if (daemonIpcClient) {
 				try {
 					daemonIpcClient.stop();
@@ -707,10 +945,13 @@ const plugin = {
 					error: "Sync engine not initialized — run `alfe login`"
 				};
 				try {
-					lastSyncResult = await syncEngine.fullSync({ quiet: true });
-					return {
+					const result = await runFullSync(syncEngine, log, "sync.now");
+					return result ? {
 						ok: true,
-						result: lastSyncResult
+						result
+					} : {
+						ok: false,
+						error: "Sync did not complete"
 					};
 				} catch (err) {
 					return {
@@ -724,12 +965,7 @@ const plugin = {
 				ok: true,
 				initialized: !!syncEngine,
 				agentId,
-				schedule: currentConfig.syncSchedule ?? "daily",
-				scope: currentConfig.syncScope ?? [
-					"config",
-					"conversations",
-					"memory"
-				],
+				schedule: currentConfig.syncSchedule ?? "realtime",
 				lastResult: lastSyncResult,
 				watcherActive: !!stopWatcher
 			}));
@@ -749,6 +985,7 @@ const plugin = {
 		log.info("Alfe Sync plugin deactivating...");
 		clearSchedule();
 		disconnectSyncRelay();
+		deleteBrake = null;
 		if (stopWatcher) {
 			try {
 				await stopWatcher();
@@ -785,22 +1022,28 @@ const plugin = {
 		};
 		if (config.syncSchedule) {
 			if (config.syncSchedule === "realtime" && syncEngine && !stopWatcher) {
+				clearSchedule();
+				const engine = syncEngine;
+				try {
+					const reconciled = await enqueueSyncOperation(async () => {
+						if (syncEngine !== engine) return null;
+						return engine.firstRunReconcile({ quiet: true });
+					});
+					if (reconciled) lastSyncResult = reconciled;
+				} catch (err) {
+					log.warn(`Realtime reconfigure reconcile failed: ${err instanceof Error ? err.message : String(err)}`);
+				}
+				const workspacePath = currentConfig.workspacePath ?? syncEngine.workspacePath;
+				deleteBrake = createDeleteBrake();
 				stopWatcher = await startWatcher({
-					workspacePath: currentConfig.workspacePath ?? syncEngine.workspacePath,
+					workspacePath,
 					runtime: syncEngine.runtime,
 					debounceMs: 2e3,
-					onChanges: async (paths) => {
-						if (!syncEngine) return;
-						try {
-							lastSyncResult = await syncEngine.push(paths, { quiet: true });
-						} catch (err) {
-							log.error(`Realtime push failed: ${err instanceof Error ? err.message : String(err)}`);
-						}
-					}
+					onChanges: (paths) => handleRealtimeChanges(paths, workspacePath, log)
 				});
-				clearSchedule();
 				log.info("Switched to realtime sync");
 			} else if (config.syncSchedule !== "realtime") {
+				deleteBrake = null;
 				if (stopWatcher) {
 					await stopWatcher();
 					stopWatcher = null;
@@ -808,7 +1051,6 @@ const plugin = {
 				setupSchedule(config.syncSchedule, log);
 			}
 		}
-		if (config.syncScope) log.info(`Updated sync scope: ${config.syncScope.join(", ")}`);
 		log.info("Alfe Sync plugin reconfigured");
 	}
 };