@alfe.ai/openclaw-sync 0.0.13 → 0.0.15

package/dist/plugin2.js

@@ -0,0 +1,749 @@
+import { i as shouldIgnore, r as loadIgnorePatterns } from "./ignore.js";
+import { m as readConfig, p as isInitialized, t as createSyncEngine } from "./sync-engine.js";
+import { createRequire } from "node:module";
+import { mkdir, rm, unlink, writeFile } from "node:fs/promises";
+import { dirname, join, normalize, relative, sep } from "node:path";
+import { watch } from "chokidar";
+import { DEFAULT_SOCKET_PATH, DEFAULT_WORKSPACE_PATH, resolveConfig } from "@alfe.ai/config";
+//#region src/watcher.ts
+/**
+* AlfeSync watcher — recursive file watcher with debounce and ignore support.
+*
+* Uses chokidar to watch the workspace root, debounces per-file changes
+* by 2 seconds, and emits batches of changed paths.
+*/
+/**
+* Start watching a workspace for file changes.
+*
+* Returns a cleanup function to stop watching.
+*/
+async function startWatcher(options) {
+	const { workspacePath, debounceMs = 2e3, onChanges } = options;
+	const ignorePatterns = await loadIgnorePatterns(workspacePath);
+	const pending = /* @__PURE__ */ new Map();
+	let batchPaths = /* @__PURE__ */ new Set();
+	let flushTimer = null;
+	function scheduleBatch() {
+		if (flushTimer) return;
+		flushTimer = setTimeout(() => {
+			flushTimer = null;
+			if (batchPaths.size === 0) return;
+			const paths = [...batchPaths];
+			batchPaths = /* @__PURE__ */ new Set();
+			onChanges(paths);
+		}, debounceMs);
+	}
+	function handleChange(absolutePath) {
+		const relativePath = relative(workspacePath, absolutePath);
+		if (shouldIgnore(relativePath, ignorePatterns)) return;
+		const existingTimer = pending.get(relativePath);
+		if (existingTimer) clearTimeout(existingTimer);
+		const timer = setTimeout(() => {
+			pending.delete(relativePath);
+			batchPaths.add(relativePath);
+			scheduleBatch();
+		}, debounceMs);
+		pending.set(relativePath, timer);
+	}
+	const watcher = watch(workspacePath, {
+		persistent: true,
+		ignoreInitial: true,
+		followSymlinks: false,
+		depth: void 0,
+		ignored: [
+			"**/node_modules/**",
+			"**/.alfesync/**",
+			"**/.git/**",
+			"**/.sst/**"
+		]
+	});
+	watcher.on("add", handleChange);
+	watcher.on("change", handleChange);
+	watcher.on("unlink", handleChange);
+	return async () => {
+		for (const timer of pending.values()) clearTimeout(timer);
+		pending.clear();
+		if (flushTimer) {
+			clearTimeout(flushTimer);
+			flushTimer = null;
+		}
+		await watcher.close();
+	};
+}
+//#endregion
+//#region src/shared-sync.ts
+/**
+* Shared file sync engine for org/team/project scoped files.
+*
+* Syncs shared files to a `shared/` directory in the agent's workspace,
+* organized by scope: shared/org/, shared/teams/{id}/, shared/projects/{id}/
+*
+* Uses the agent self-service API (/agents/org/...) with the agent's API key.
+*/
+const MAX_SHARED_FILE_SIZE = 100 * 1024 * 1024;
+/** Verify that resolvedPath stays within baseDir. Prevents path traversal. */
+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 fetchJson(url, token) {
+	const response = await fetch(url, { headers: {
+		"Authorization": `Bearer ${token}`,
+		"Content-Type": "application/json"
+	} });
+	if (!response.ok) {
+		let errorBody = "";
+		try {
+			errorBody = await response.text();
+		} catch {
+			errorBody = "(unable to read error body)";
+		}
+		throw new Error(`HTTP ${String(response.status)}: ${errorBody}`);
+	}
+	return response.json();
+}
+function createSharedSyncEngine(config, log) {
+	let activeScopes = [];
+	const sharedDir = join(config.workspacePath, "shared");
+	function scopeDir(scope) {
+		if (scope.scopeType === "org") return join(sharedDir, "org");
+		return join(sharedDir, scope.scopeType === "team" ? "teams" : "projects", scope.scopeId);
+	}
+	function apiBase() {
+		return `${config.apiUrl}/agents/org`;
+	}
+	async function listRemoteFiles(scope) {
+		return (await fetchJson(`${apiBase()}/files/${scope.scopeType}/${scope.scopeId}`, config.token)).files;
+	}
+	async function downloadFile(scope, filePath, localPath) {
+		assertContained(scopeDir(scope), localPath);
+		const result = await fetchJson(`${apiBase()}/files/${scope.scopeType}/${scope.scopeId}/${encodeURIComponent(filePath)}/download`, config.token);
+		const response = await fetch(result.downloadUrl);
+		if (!response.ok) throw new Error(`Download failed: HTTP ${String(response.status)}`);
+		const contentLength = parseInt(response.headers.get("content-length") ?? "0", 10);
+		if (contentLength > MAX_SHARED_FILE_SIZE) throw new Error(`File too large: ${String(contentLength)} bytes exceeds ${String(MAX_SHARED_FILE_SIZE)} limit`);
+		const buffer = Buffer.from(await response.arrayBuffer());
+		if (buffer.length > MAX_SHARED_FILE_SIZE) throw new Error(`Downloaded file exceeds size limit: ${String(buffer.length)} bytes`);
+		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 remoteFiles = await listRemoteFiles(scope);
+			for (const file of remoteFiles) {
+				const localPath = join(dir, file.filePath);
+				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)}`);
+				}
+			}
+		} catch (err) {
+			log.error(`Shared sync: failed to list files for ${scope.scopeType}/${scope.scopeId}: ${err instanceof Error ? err.message : String(err)}`);
+		}
+	}
+	function parseScopedPath(filePath) {
+		if (filePath.includes("..")) 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]
+			};
+		}
+		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]
+			};
+		}
+		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]
+			};
+		}
+		return null;
+	}
+	return {
+		async initialize(scopes) {
+			activeScopes = [...scopes];
+			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 oldIds = new Set(activeScopes.map((s) => `${s.scopeType}:${s.scopeId}`));
+			const newIds = new Set(newScopes.map((s) => `${s.scopeType}:${s.scopeId}`));
+			for (const scope of activeScopes) {
+				const key = `${scope.scopeType}:${scope.scopeId}`;
+				if (!newIds.has(key)) {
+					const dir = scopeDir(scope);
+					try {
+						await rm(dir, {
+							recursive: true,
+							force: true
+						});
+						log.info(`Shared sync: removed scope directory ${dir}`);
+					} catch (err) {
+						log.warn(`Shared sync: failed to remove ${dir}: ${err instanceof Error ? err.message : String(err)}`);
+					}
+				}
+			}
+			for (const scope of newScopes) {
+				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];
+		},
+		async handleNotification(filePath, eventType) {
+			const parsed = parseScopedPath(filePath);
+			if (!parsed) {
+				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 {
+				log.warn(`Shared sync: path traversal blocked for ${filePath}`);
+				return;
+			}
+			if (eventType === "deleted") {
+				try {
+					await unlink(localPath);
+					log.debug(`Shared sync: deleted ${filePath}`);
+				} catch {}
+				return;
+			}
+			try {
+				await downloadFile(parsed.scope, parsed.relativePath, localPath);
+				log.debug(`Shared sync: pulled ${filePath}`);
+			} catch (err) {
+				log.error(`Shared sync: failed to pull ${filePath}: ${err instanceof Error ? err.message : String(err)}`);
+			}
+		},
+		async fullSync() {
+			log.info(`Shared sync: full sync across ${String(activeScopes.length)} scope(s)`);
+			for (const scope of activeScopes) await syncScope(scope);
+		},
+		getScopes() {
+			return [...activeScopes];
+		}
+	};
+}
+//#endregion
+//#region src/plugin.ts
+/**
+* @alfe.ai/openclaw-sync — OpenClaw Sync plugin.
+*
+* Wraps the existing sync engine as a lifecycle-managed integration,
+* following the same plugin pattern as @alfe.ai/openclaw-mobile and
+* @alfe.ai/openclaw-discord.
+*
+* Lifecycle:
+*   - activate(api): start the sync engine + watcher based on config
+*   - deactivate(api): stop the watcher, clean up resources
+*   - configure(api, config): update scope/schedule at runtime
+*
+* Registers 'sync.now' and 'sync.status' gateway RPC methods.
+*/
+const pkg = createRequire(import.meta.url)("../package.json");
+const SYNC_CAPABILITIES = [
+	"sync.push",
+	"sync.pull",
+	"sync.fullSync"
+];
+const SYNC_RELAY_RECONNECT_BASE_MS = 1e3;
+const SYNC_RELAY_RECONNECT_MAX_MS = 3e4;
+const SYNC_RELAY_DEBOUNCE_MS = 500;
+let syncEngine = null;
+let sharedSyncEngine = null;
+let stopWatcher = null;
+let daemonIpcClient = null;
+let scheduledInterval = null;
+let currentConfig = {};
+let lastSyncResult = null;
+let syncRelayWs = null;
+let syncRelayReconnectTimer = null;
+let syncRelayReconnectAttempt = 0;
+let syncRelayDebounceTimer = null;
+const syncRelayPendingPaths = /* @__PURE__ */ new Map();
+const SCHEDULE_INTERVALS_MS = {
+	hourly: 3600 * 1e3,
+	daily: 1440 * 60 * 1e3,
+	weekly: 10080 * 60 * 1e3
+};
+function clearSchedule() {
+	if (scheduledInterval) {
+		clearInterval(scheduledInterval);
+		scheduledInterval = null;
+	}
+}
+function setupSchedule(schedule, log) {
+	clearSchedule();
+	if (schedule === "realtime") {
+		log.info("Sync schedule: realtime (file watcher active)");
+		return;
+	}
+	const intervalMs = SCHEDULE_INTERVALS_MS[schedule];
+	if (!intervalMs) {
+		log.warn(`Unknown sync schedule: ${schedule}, defaulting to hourly`);
+		setupSchedule("hourly", log);
+		return;
+	}
+	log.info(`Sync schedule: ${schedule} (every ${String(intervalMs / 1e3)}s)`);
+	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)}`);
+			}
+		})();
+	}, intervalMs);
+}
+async function connectToDaemon(socketPath, log) {
+	try {
+		const IPCClient = (await import("@alfe.ai/openclaw")).IPCClient;
+		const client = new IPCClient(socketPath, log);
+		client.on("connected", () => {
+			(async () => {
+				log.info("Connected to Alfe daemon — registering sync capabilities...");
+				const response = await client.request("capability.register", {
+					plugin: "@alfe.ai/openclaw-sync",
+					capabilities: [...SYNC_CAPABILITIES]
+				});
+				if (response.ok) log.info("Sync capabilities registered with daemon");
+				else log.warn(`Failed to register sync capabilities: ${response.error?.message ?? "unknown"}`);
+			})();
+		});
+		client.on("disconnected", (...args) => {
+			const reason = typeof args[0] === "string" ? args[0] : String(args[0]);
+			log.warn(`Disconnected from Alfe daemon: ${reason}`);
+		});
+		client.on("message", (...args) => {
+			const msg = args[0];
+			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 (msg?.type === "SHARED_SCOPES") {
+				const scopes = msg.scopes;
+				const engine = sharedSyncEngine;
+				if (scopes && engine) {
+					log.info(`Received SHARED_SCOPES update: ${String(scopes.length)} scope(s)`);
+					(async () => {
+						try {
+							await engine.updateScopes(scopes);
+						} catch (err) {
+							log.error(`SHARED_SCOPES update failed: ${err instanceof Error ? err.message : String(err)}`);
+						}
+					})();
+				}
+			}
+		});
+		client.on("error", (...args) => {
+			const err = args[0];
+			log.debug(`Daemon IPC error: ${err instanceof Error ? err.message : String(err)}`);
+		});
+		client.start();
+		return client;
+	} catch {
+		log.info("Alfe daemon not available — Sync plugin running standalone");
+		return null;
+	}
+}
+function clearSyncRelayReconnect() {
+	if (syncRelayReconnectTimer) {
+		clearTimeout(syncRelayReconnectTimer);
+		syncRelayReconnectTimer = null;
+	}
+}
+function clearSyncRelayDebounce() {
+	if (syncRelayDebounceTimer) {
+		clearTimeout(syncRelayDebounceTimer);
+		syncRelayDebounceTimer = null;
+	}
+}
+async function processPendingNotifications(log) {
+	if (syncRelayPendingPaths.size === 0) return;
+	const entries = new Map(syncRelayPendingPaths);
+	syncRelayPendingPaths.clear();
+	const sharedEntries = /* @__PURE__ */ new Map();
+	const privateEntries = /* @__PURE__ */ new Map();
+	for (const [filePath, info] of entries) if (filePath.startsWith("shared/")) sharedEntries.set(filePath, info);
+	else privateEntries.set(filePath, info);
+	if (sharedEntries.size > 0 && sharedSyncEngine) for (const [filePath, info] of sharedEntries) try {
+		await sharedSyncEngine.handleNotification(filePath, info.eventType);
+	} catch (err) {
+		log.error(`Shared sync relay: failed ${info.eventType} ${filePath}: ${err instanceof Error ? err.message : String(err)}`);
+	}
+	if (privateEntries.size > 0 && syncEngine) {
+		const engine = syncEngine;
+		const toPull = [];
+		const toDelete = [];
+		for (const [filePath, info] of privateEntries) if (info.eventType === "deleted") toDelete.push(filePath);
+		else toPull.push(filePath);
+		for (const filePath of toDelete) try {
+			await engine.removeLocalFile(filePath, { quiet: true });
+			log.debug(`Sync relay: deleted ${filePath}`);
+		} catch (err) {
+			log.error(`Sync relay: failed to delete ${filePath}: ${err instanceof Error ? err.message : String(err)}`);
+		}
+		if (toPull.length > 0) try {
+			const result = await engine.pullFiles(toPull, { quiet: true });
+			if (result.pulled > 0) log.info(`Sync relay: pulled ${String(result.pulled)} file(s)`);
+			if (result.errors > 0) log.warn(`Sync relay: ${String(result.errors)} pull error(s)`);
+		} catch (err) {
+			log.error(`Sync relay: pull failed: ${err instanceof Error ? err.message : String(err)}`);
+		}
+	}
+}
+async function connectToSyncRelay(relayUrl, token, agentId, log) {
+	try {
+		const { default: WebSocket } = await import("ws");
+		const ws = new WebSocket(`${relayUrl}?token=${encodeURIComponent(token)}`);
+		ws.on("open", () => {
+			log.info("Connected to Sync Relay");
+			syncRelayReconnectAttempt = 0;
+			ws.send(JSON.stringify({
+				type: "SUBSCRIBE",
+				agentId
+			}));
+		});
+		ws.on("message", (data) => {
+			let message;
+			try {
+				message = JSON.parse(data.toString());
+			} catch {
+				return;
+			}
+			switch (message.type) {
+				case "SUBSCRIBE_ACK":
+					if (message.status === "ok") {
+						log.info(`Subscribed to sync notifications for agent ${message.agentId ?? agentId}`);
+						const sharedEngine = sharedSyncEngine;
+						if (sharedEngine) (async () => {
+							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, {
+						etag: message.etag,
+						eventType: message.eventType === "deleted" ? "deleted" : "created"
+					});
+					clearSyncRelayDebounce();
+					syncRelayDebounceTimer = setTimeout(() => {
+						processPendingNotifications(log);
+					}, SYNC_RELAY_DEBOUNCE_MS);
+					break;
+				case "PING":
+					try {
+						ws.send(JSON.stringify({ type: "PONG" }));
+					} catch {}
+					break;
+			}
+		});
+		ws.on("close", (code) => {
+			log.info(`Sync Relay disconnected (code=${String(code)})`);
+			syncRelayWs = null;
+			scheduleSyncRelayReconnect(relayUrl, token, agentId, log);
+		});
+		ws.on("error", (err) => {
+			log.debug(`Sync Relay error: ${err.message}`);
+		});
+		return ws;
+	} catch (err) {
+		log.debug(`Failed to connect to Sync Relay: ${err instanceof Error ? err.message : String(err)}`);
+		scheduleSyncRelayReconnect(relayUrl, token, agentId, log);
+		return null;
+	}
+}
+function scheduleSyncRelayReconnect(relayUrl, token, agentId, log) {
+	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, agentId, log);
+		})();
+	}, delay);
+}
+function disconnectSyncRelay() {
+	clearSyncRelayReconnect();
+	clearSyncRelayDebounce();
+	syncRelayPendingPaths.clear();
+	if (syncRelayWs) {
+		try {
+			syncRelayWs.send(JSON.stringify({ type: "UNSUBSCRIBE" }));
+			syncRelayWs.close(1e3, "Plugin deactivating");
+		} catch {}
+		syncRelayWs = null;
+	}
+}
+const plugin = {
+	id: "@alfe.ai/openclaw-sync",
+	name: "Alfe Sync Plugin",
+	description: "Back up agent configuration, conversations, and memory to the cloud with scheduled or real-time sync.",
+	version: pkg.version,
+	activate(api) {
+		const log = api.logger;
+		const pluginConfig = api.config ?? {};
+		currentConfig = pluginConfig;
+		let alfeConfig = null;
+		try {
+			alfeConfig = resolveConfig();
+		} catch {}
+		const workspacePath = pluginConfig.workspacePath ?? alfeConfig?.workspacePath ?? DEFAULT_WORKSPACE_PATH;
+		const syncScope = pluginConfig.syncScope ?? [
+			"config",
+			"conversations",
+			"memory"
+		];
+		const syncSchedule = pluginConfig.syncSchedule ?? "daily";
+		const socketPath = pluginConfig.socketPath ?? alfeConfig?.socketPath ?? DEFAULT_SOCKET_PATH;
+		const startSyncService = async () => {
+			if (globalThis.__alfeSyncPluginActivated === true) {
+				log.debug("Alfe Sync plugin already activated — skipping duplicate");
+				return;
+			}
+			globalThis.__alfeSyncPluginActivated = true;
+			log.info("Alfe Sync plugin activating...");
+			log.info(`Sync scope: ${syncScope.join(", ")}`);
+			log.info(`Sync schedule: ${syncSchedule}`);
+			log.info(`Workspace: ${workspacePath}`);
+			if (isInitialized(workspacePath)) try {
+				syncEngine = await createSyncEngine(workspacePath);
+				log.info("Sync engine initialized");
+			} catch (err) {
+				log.warn(`Failed to initialize sync engine: ${err instanceof Error ? err.message : String(err)}`);
+				log.warn("Sync will be available once the workspace is configured (alfesync init)");
+			}
+			else log.info("Workspace not initialized for sync — run alfesync init to enable");
+			if (syncSchedule === "realtime" && syncEngine) try {
+				stopWatcher = await startWatcher({
+					workspacePath,
+					debounceMs: 2e3,
+					onChanges: async (paths) => {
+						if (!syncEngine) return;
+						log.debug(`Realtime sync: ${String(paths.length)} file(s) changed`);
+						try {
+							lastSyncResult = await syncEngine.push(paths, { quiet: true });
+						} catch (err) {
+							log.error(`Realtime push failed: ${err instanceof Error ? err.message : String(err)}`);
+						}
+					}
+				});
+				log.info("File watcher started for realtime sync");
+			} catch (err) {
+				log.warn(`Failed to start file watcher: ${err instanceof Error ? err.message : String(err)}`);
+			}
+			if (syncSchedule !== "realtime" && syncEngine) setupSchedule(syncSchedule, log);
+			daemonIpcClient = await connectToDaemon(socketPath, log);
+			if (syncEngine) try {
+				const config = await readConfig(workspacePath);
+				if (config) {
+					const defaultRelayUrl = config.apiUrl.includes("dev.alfe.ai") ? "wss://sync.dev.alfe.ai/ws" : "wss://sync.alfe.ai/ws";
+					syncRelayWs = await connectToSyncRelay(pluginConfig.syncRelayUrl ?? defaultRelayUrl, config.token, config.agentId, log);
+				}
+			} catch (err) {
+				log.debug(`Sync Relay connection skipped: ${err instanceof Error ? err.message : String(err)}`);
+			}
+			if (syncEngine && pluginConfig.sharedSync !== false) try {
+				const sharedConfig = await readConfig(workspacePath);
+				if (sharedConfig) {
+					sharedSyncEngine = createSharedSyncEngine({
+						workspacePath,
+						apiUrl: sharedConfig.apiUrl,
+						token: sharedConfig.token,
+						agentId: sharedConfig.agentId
+					}, log);
+					log.info("Shared sync engine created — waiting for SHARED_SCOPES from gateway");
+				}
+			} catch (err) {
+				log.debug(`Shared sync engine skipped: ${err instanceof Error ? err.message : String(err)}`);
+			}
+		};
+		const stopSyncService = async () => {
+			globalThis.__alfeSyncPluginActivated = false;
+			clearSchedule();
+			disconnectSyncRelay();
+			if (stopWatcher) {
+				try {
+					await stopWatcher();
+					log.info("File watcher stopped");
+				} catch (err) {
+					log.debug(`Error stopping watcher: ${err instanceof Error ? err.message : String(err)}`);
+				}
+				stopWatcher = null;
+			}
+			if (daemonIpcClient) {
+				try {
+					daemonIpcClient.stop();
+					log.info("Disconnected from Alfe daemon");
+				} catch (err) {
+					log.debug(`Error disconnecting from daemon: ${err instanceof Error ? err.message : String(err)}`);
+				}
+				daemonIpcClient = null;
+			}
+			syncEngine = null;
+			sharedSyncEngine = null;
+			lastSyncResult = null;
+			currentConfig = {};
+			log.info("Alfe Sync plugin deactivated");
+		};
+		if (typeof api.registerGatewayMethod === "function") {
+			api.registerGatewayMethod("sync.now", async () => {
+				if (!syncEngine) return {
+					ok: false,
+					error: "Sync engine not initialized — run alfesync init"
+				};
+				try {
+					lastSyncResult = await syncEngine.fullSync({ quiet: true });
+					return {
+						ok: true,
+						result: lastSyncResult
+					};
+				} catch (err) {
+					return {
+						ok: false,
+						error: err instanceof Error ? err.message : String(err)
+					};
+				}
+			});
+			log.info("Registered gateway RPC method: sync.now");
+			api.registerGatewayMethod("sync.status", () => {
+				return Promise.resolve({
+					ok: true,
+					initialized: !!syncEngine,
+					schedule: currentConfig.syncSchedule ?? "daily",
+					scope: currentConfig.syncScope ?? [
+						"config",
+						"conversations",
+						"memory"
+					],
+					lastResult: lastSyncResult,
+					watcherActive: !!stopWatcher
+				});
+			});
+			log.info("Registered gateway RPC method: sync.status");
+		}
+		if (api.registerService) api.registerService({
+			id: "alfe-sync-engine",
+			start: () => startSyncService(),
+			stop: () => stopSyncService()
+		});
+		else startSyncService().catch((err) => {
+			log.error(`Sync plugin async init failed: ${err instanceof Error ? err.message : String(err)}`);
+		});
+		log.info("Alfe Sync plugin activated");
+	},
+	async deactivate(api) {
+		globalThis.__alfeSyncPluginActivated = false;
+		const log = api.logger;
+		log.info("Alfe Sync plugin deactivating...");
+		clearSchedule();
+		disconnectSyncRelay();
+		if (stopWatcher) {
+			try {
+				await stopWatcher();
+				log.info("File watcher stopped");
+			} catch (err) {
+				log.debug(`Error stopping watcher: ${err instanceof Error ? err.message : String(err)}`);
+			}
+			stopWatcher = null;
+		}
+		if (daemonIpcClient) {
+			try {
+				daemonIpcClient.stop();
+				log.info("Disconnected from Alfe daemon");
+			} catch (err) {
+				log.debug(`Error disconnecting from daemon: ${err instanceof Error ? err.message : String(err)}`);
+			}
+			daemonIpcClient = null;
+		}
+		syncEngine = null;
+		sharedSyncEngine = null;
+		lastSyncResult = null;
+		currentConfig = {};
+		log.info("Alfe Sync plugin deactivated");
+	},
+	async configure(api, config) {
+		const log = api.logger;
+		log.info("Reconfiguring Alfe Sync plugin...");
+		currentConfig = {
+			...currentConfig,
+			...config
+		};
+		if (config.syncSchedule) {
+			if (config.syncSchedule === "realtime" && syncEngine && !stopWatcher) {
+				let cfgForWorkspace = null;
+				try {
+					cfgForWorkspace = resolveConfig();
+				} catch {}
+				stopWatcher = await startWatcher({
+					workspacePath: currentConfig.workspacePath ?? cfgForWorkspace?.workspacePath ?? "",
+					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)}`);
+						}
+					}
+				});
+				clearSchedule();
+				log.info("Switched to realtime sync");
+			} else if (config.syncSchedule !== "realtime") {
+				if (stopWatcher) {
+					await stopWatcher();
+					stopWatcher = null;
+				}
+				setupSchedule(config.syncSchedule, log);
+			}
+		}
+		if (config.syncScope) log.info(`Updated sync scope: ${config.syncScope.join(", ")}`);
+		log.info("Alfe Sync plugin reconfigured");
+	}
+};
+//#endregion
+export { createSharedSyncEngine as n, startWatcher as r, plugin as t };
+
+//# sourceMappingURL=plugin2.js.map