@alfe.ai/openclaw-sync 0.0.1

package/dist/sync-engine.js

@@ -0,0 +1,672 @@
+import { r as loadIgnorePatterns, t as filterIgnored } from "./ignore.js";
+import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import { createReadStream, existsSync } from "node:fs";
+import { basename, dirname, extname, join } from "node:path";
+import { createHash } from "node:crypto";
+import { createLogger } from "@auriclabs/logger";
+//#region src/config.ts
+/**
+* AlfeSync configuration — read/write `.alfesync/config.json` in workspace root.
+*/
+const CONFIG_DIR = ".alfesync";
+const CONFIG_FILE = "config.json";
+/**
+* Resolve the .alfesync directory path for a given workspace root.
+*/
+function configDir(workspacePath) {
+	return join(workspacePath, CONFIG_DIR);
+}
+/**
+* Resolve the config file path for a given workspace root.
+*/
+function configPath(workspacePath) {
+	return join(workspacePath, CONFIG_DIR, CONFIG_FILE);
+}
+/**
+* Check if a workspace has been initialized with AlfeSync.
+*/
+function isInitialized(workspacePath) {
+	return existsSync(configPath(workspacePath));
+}
+/**
+* Read the AlfeSync config from a workspace.
+* Returns null if not initialized.
+*/
+async function readConfig(workspacePath) {
+	const path = configPath(workspacePath);
+	if (!existsSync(path)) return null;
+	try {
+		const raw = await readFile(path, "utf-8");
+		const parsed = JSON.parse(raw);
+		if (!parsed.agentId || !parsed.token || !parsed.apiUrl) return null;
+		return {
+			...parsed,
+			workspacePath
+		};
+	} catch {
+		return null;
+	}
+}
+/**
+* Write the AlfeSync config to a workspace.
+* Creates the .alfesync directory if it doesn't exist.
+*/
+async function writeConfig(config) {
+	await mkdir(configDir(config.workspacePath), { recursive: true });
+	const path = configPath(config.workspacePath);
+	const data = {
+		agentId: config.agentId,
+		orgId: config.orgId,
+		token: config.token,
+		workspacePath: config.workspacePath,
+		apiUrl: config.apiUrl
+	};
+	await writeFile(path, JSON.stringify(data, null, 2) + "\n", "utf-8");
+}
+/**
+* Load config from workspace, throwing if not initialized.
+*/
+async function requireConfig(workspacePath) {
+	const config = await readConfig(workspacePath);
+	if (!config) throw new Error(`AlfeSync not initialized in ${workspacePath}. Run: alfesync init`);
+	return config;
+}
+//#endregion
+//#region src/manifest.ts
+/**
+* AlfeSync manifest — local file manifest at `.alfesync/manifest.json`.
+*
+* Tracks file hashes, sizes, sync timestamps, and storage classes
+* to enable efficient diff-based syncing.
+*/
+const MANIFEST_FILE = "manifest.json";
+/**
+* Resolve the manifest file path for a given workspace root.
+*/
+function manifestPath(workspacePath) {
+	return join(configDir(workspacePath), MANIFEST_FILE);
+}
+/**
+* Read the local manifest. Returns empty manifest if not found.
+*/
+async function readManifest(workspacePath) {
+	const path = manifestPath(workspacePath);
+	if (!existsSync(path)) return { files: {} };
+	try {
+		const raw = await readFile(path, "utf-8");
+		return JSON.parse(raw);
+	} catch {
+		return { files: {} };
+	}
+}
+/**
+* Write the local manifest.
+*/
+async function writeManifest(workspacePath, manifest) {
+	await mkdir(configDir(workspacePath), { recursive: true });
+	await writeFile(manifestPath(workspacePath), JSON.stringify(manifest, null, 2) + "\n", "utf-8");
+}
+/**
+* Update a single file entry in the local manifest.
+*/
+async function updateManifestEntry(workspacePath, relativePath, entry) {
+	const manifest = await readManifest(workspacePath);
+	manifest.files[relativePath] = entry;
+	await writeManifest(workspacePath, manifest);
+}
+/**
+* Remove a file entry from the local manifest.
+*/
+async function removeManifestEntry(workspacePath, relativePath) {
+	const manifest = await readManifest(workspacePath);
+	manifest.files = Object.fromEntries(Object.entries(manifest.files).filter(([key]) => key !== relativePath));
+	await writeManifest(workspacePath, manifest);
+}
+/**
+* Compute SHA-256 hash of a file using streaming (memory-efficient).
+* Returns `sha256:<hex>` format.
+*/
+async function computeFileHash(filePath) {
+	return new Promise((resolve, reject) => {
+		const hash = createHash("sha256");
+		const stream = createReadStream(filePath);
+		stream.on("data", (chunk) => hash.update(chunk));
+		stream.on("end", () => {
+			resolve(`sha256:${hash.digest("hex")}`);
+		});
+		stream.on("error", reject);
+	});
+}
+/**
+* Diff the local manifest against the remote manifest.
+*
+* Returns lists of files to push, pull, and conflicts.
+*/
+function diffManifests(local, remote) {
+	const toPush = [];
+	const toPull = [];
+	const conflicts = [];
+	const remoteDeleted = [];
+	const localPaths = new Set(Object.keys(local.files));
+	const remotePaths = new Set(Object.keys(remote.files));
+	for (const path of localPaths) if (!remotePaths.has(path)) toPush.push(path);
+	for (const path of remotePaths) if (!localPaths.has(path)) toPull.push(path);
+	for (const path of localPaths) {
+		if (!remotePaths.has(path)) continue;
+		const localEntry = local.files[path];
+		const remoteEntry = remote.files[path];
+		if (localEntry.hash === remoteEntry.hash) continue;
+		const localSyncTime = new Date(localEntry.lastSynced).getTime();
+		if (new Date(remoteEntry.modified).getTime() > localSyncTime) conflicts.push(path);
+		else toPush.push(path);
+	}
+	for (const path of localPaths) if (local.files[path].lastSynced !== "" && !remotePaths.has(path)) remoteDeleted.push(path);
+	return {
+		toPush,
+		toPull,
+		conflicts,
+		remoteDeleted
+	};
+}
+//#endregion
+//#region src/api-client.ts
+/**
+* Create an AlfeSync API client.
+*/
+function createApiClient(config) {
+	const { apiUrl, token, agentId } = config;
+	const baseUrl = apiUrl.replace(/\/$/, "");
+	async function request(method, path, body) {
+		const url = `${baseUrl}${path}`;
+		const headers = {
+			Authorization: `Bearer ${token}`,
+			"Content-Type": "application/json"
+		};
+		const response = await fetch(url, {
+			method,
+			headers,
+			body: body ? JSON.stringify(body) : void 0
+		});
+		if (!response.ok) {
+			const text = await response.text();
+			let errorMsg;
+			try {
+				const parsed = JSON.parse(text);
+				errorMsg = (typeof parsed.error === "string" ? parsed.error : void 0) ?? (typeof parsed.message === "string" ? parsed.message : void 0) ?? text;
+			} catch {
+				errorMsg = text;
+			}
+			throw new Error(`AlfeSync API error (${String(response.status)}): ${errorMsg}`);
+		}
+		const json = await response.json();
+		if (!json.success) throw new Error("AlfeSync API returned unsuccessful response");
+		return json.data;
+	}
+	return {
+		async getManifest() {
+			return request("GET", `/sync/agents/${agentId}/manifest`);
+		},
+		async presignPut(filePath, contentType = "application/octet-stream") {
+			return (await request("POST", `/sync/agents/${agentId}/presign`, { files: [{
+				path: filePath,
+				operation: "put",
+				contentType
+			}] })).urls[0];
+		},
+		async presignPutBatch(files) {
+			return (await request("POST", `/sync/agents/${agentId}/presign`, { files: files.map((f) => ({
+				path: f.path,
+				operation: "put",
+				contentType: f.contentType ?? "application/octet-stream"
+			})) })).urls;
+		},
+		async confirmUpload(filePath, hash, size, storageClass = "STANDARD") {
+			return request("POST", `/sync/agents/${agentId}/files/${filePath}/confirm`, {
+				hash,
+				size,
+				storageClass
+			});
+		},
+		async presignGet(filePath) {
+			return (await request("POST", `/sync/agents/${agentId}/presign`, { files: [{
+				path: filePath,
+				operation: "get"
+			}] })).urls[0];
+		},
+		async presignGetBatch(paths) {
+			return (await request("POST", `/sync/agents/${agentId}/presign`, { files: paths.map((p) => ({
+				path: p,
+				operation: "get"
+			})) })).urls;
+		},
+		async getStats() {
+			return request("GET", `/sync/agents/${agentId}/stats`);
+		},
+		async registerAgent(displayName) {
+			return request("POST", "/sync/agents", {
+				agentId,
+				displayName
+			});
+		},
+		async getFileHistory(filePath) {
+			return (await request("GET", `/sync/agents/${agentId}/files/${filePath}/versions`)).versions;
+		},
+		async reconstruct(mode = "full") {
+			return request("POST", `/sync/agents/${agentId}/reconstruct`, { mode });
+		}
+	};
+}
+//#endregion
+//#region src/uploader.ts
+/**
+* AlfeSync uploader — upload changed files to S3 via presigned URLs.
+*
+* Flow per file:
+*   1. Request presigned PUT URL from API
+*   2. PUT file content directly to S3
+*   3. Notify API of completion (confirm endpoint)
+*   4. Update local manifest
+*
+* Retries 3x with exponential backoff on transient failures.
+*/
+const log$2 = createLogger("SyncUploader");
+const MAX_RETRIES$1 = 3;
+const BASE_DELAY_MS$1 = 1e3;
+/**
+* Determine the storage class based on file path.
+*/
+function getStorageClass(relativePath) {
+	return relativePath.startsWith("sessions/archive/") || relativePath.startsWith("context/archive/") ? "GLACIER_IR" : "STANDARD";
+}
+/**
+* Determine MIME type from file path.
+*/
+function getContentType(relativePath) {
+	if (relativePath.endsWith(".json")) return "application/json";
+	if (relativePath.endsWith(".md")) return "text/markdown";
+	if (relativePath.endsWith(".txt")) return "text/plain";
+	if (relativePath.endsWith(".gz")) return "application/gzip";
+	if (relativePath.endsWith(".yaml") || relativePath.endsWith(".yml")) return "text/yaml";
+	return "application/octet-stream";
+}
+/**
+* Upload a single file with retry logic.
+*/
+async function uploadFileWithRetry(workspacePath, relativePath, client) {
+	const absolutePath = join(workspacePath, relativePath);
+	let lastError;
+	for (let attempt = 0; attempt <= MAX_RETRIES$1; attempt++) try {
+		const [hash, fileStat] = await Promise.all([computeFileHash(absolutePath), stat(absolutePath)]);
+		const size = fileStat.size;
+		const storageClass = getStorageClass(relativePath);
+		const contentType = getContentType(relativePath);
+		const presigned = await client.presignPut(relativePath, contentType);
+		const fileContent = await readFile(absolutePath);
+		const putResponse = await fetch(presigned.url, {
+			method: "PUT",
+			headers: { "Content-Type": contentType },
+			body: fileContent
+		});
+		if (!putResponse.ok) throw new Error(`S3 PUT failed (${String(putResponse.status)}): ${await putResponse.text()}`);
+		await client.confirmUpload(relativePath, hash, size, storageClass);
+		await updateManifestEntry(workspacePath, relativePath, {
+			hash,
+			size,
+			lastSynced: (/* @__PURE__ */ new Date()).toISOString(),
+			storageClass
+		});
+		return {
+			path: relativePath,
+			success: true,
+			hash,
+			size
+		};
+	} catch (err) {
+		lastError = err instanceof Error ? err : new Error(String(err));
+		if (attempt < MAX_RETRIES$1) {
+			const delay = BASE_DELAY_MS$1 * Math.pow(2, attempt);
+			await new Promise((resolve) => setTimeout(resolve, delay));
+		}
+	}
+	return {
+		path: relativePath,
+		success: false,
+		error: lastError?.message ?? "Unknown error"
+	};
+}
+/**
+* Upload multiple files to S3.
+*
+* Uploads are performed in parallel with a concurrency limit.
+*/
+async function uploadFiles(workspacePath, relativePaths, client, options = {}) {
+	const { concurrency = 5, quiet = false } = options;
+	const results = [];
+	for (let i = 0; i < relativePaths.length; i += concurrency) {
+		const batch = relativePaths.slice(i, i + concurrency);
+		const batchResults = await Promise.all(batch.map((path) => uploadFileWithRetry(workspacePath, path, client)));
+		for (const result of batchResults) {
+			results.push(result);
+			if (!quiet) if (result.success) log$2.info(`Uploaded ${result.path} (${formatBytes$1(result.size ?? 0)})`);
+			else log$2.error(`Failed to upload ${result.path}: ${result.error ?? "Unknown error"}`);
+		}
+	}
+	return results;
+}
+function formatBytes$1(bytes) {
+	if (bytes < 1024) return `${String(bytes)} B`;
+	if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+	return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+//#endregion
+//#region src/downloader.ts
+/**
+* AlfeSync downloader — download files from S3 via presigned URLs.
+*
+* Flow per file:
+*   1. Request presigned GET URL from API
+*   2. GET file content from S3
+*   3. Write to local disk
+*   4. Update local manifest
+*/
+const log$1 = createLogger("SyncDownloader");
+const MAX_RETRIES = 3;
+const BASE_DELAY_MS = 1e3;
+/**
+* Download a single file with retry logic.
+*/
+async function downloadFileWithRetry(workspacePath, relativePath, client, remoteEntry) {
+	let lastError;
+	for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) try {
+		const presigned = await client.presignGet(relativePath);
+		const response = await fetch(presigned.url);
+		if (!response.ok) throw new Error(`S3 GET failed (${String(response.status)}): ${await response.text()}`);
+		const buffer = Buffer.from(await response.arrayBuffer());
+		const absolutePath = join(workspacePath, relativePath);
+		await mkdir(dirname(absolutePath), { recursive: true });
+		await writeFile(absolutePath, buffer);
+		await updateManifestEntry(workspacePath, relativePath, {
+			hash: remoteEntry?.hash ?? "",
+			size: buffer.length,
+			lastSynced: (/* @__PURE__ */ new Date()).toISOString(),
+			storageClass: remoteEntry?.storageClass ?? "STANDARD"
+		});
+		return {
+			path: relativePath,
+			success: true,
+			size: buffer.length
+		};
+	} catch (err) {
+		lastError = err instanceof Error ? err : new Error(String(err));
+		if (attempt < MAX_RETRIES) {
+			const delay = BASE_DELAY_MS * Math.pow(2, attempt);
+			await new Promise((resolve) => setTimeout(resolve, delay));
+		}
+	}
+	return {
+		path: relativePath,
+		success: false,
+		error: lastError?.message ?? "Unknown error"
+	};
+}
+/**
+* Download multiple files from S3.
+*
+* Downloads are performed in parallel with a concurrency limit.
+*/
+async function downloadFiles(workspacePath, relativePaths, client, remoteManifest, options = {}) {
+	const { concurrency = 5, quiet = false } = options;
+	const results = [];
+	for (let i = 0; i < relativePaths.length; i += concurrency) {
+		const batch = relativePaths.slice(i, i + concurrency);
+		const batchResults = await Promise.all(batch.map((path) => downloadFileWithRetry(workspacePath, path, client, remoteManifest?.files[path])));
+		for (const result of batchResults) {
+			results.push(result);
+			if (!quiet) if (result.success) log$1.info(`Downloaded ${result.path} (${formatBytes(result.size ?? 0)})`);
+			else log$1.error(`Failed to download ${result.path}: ${result.error ?? "Unknown error"}`);
+		}
+	}
+	return results;
+}
+function formatBytes(bytes) {
+	if (bytes < 1024) return `${String(bytes)} B`;
+	if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+	return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+//#endregion
+//#region src/sync-engine.ts
+/**
+* AlfeSync engine — orchestrates push, pull, and full sync operations.
+*
+* Handles:
+*   - push(paths[]): upload changed files to S3
+*   - pull(): download files newer on remote
+*   - fullSync(): bidirectional sync with conflict detection
+*
+* Conflict resolution: if remote file is newer than local manifest entry
+* AND local file has changed → write `.conflict-{timestamp}` alongside original.
+*/
+const log = createLogger("SyncEngine");
+/**
+* Create a sync engine for a workspace.
+*/
+async function createSyncEngine(workspacePath) {
+	const config = await requireConfig(workspacePath);
+	const client = createApiClient({
+		apiUrl: config.apiUrl,
+		token: config.token,
+		agentId: config.agentId
+	});
+	return {
+		config,
+		client,
+		async push(paths, options = {}) {
+			const { quiet = false, filter } = options;
+			const ignorePatterns = await loadIgnorePatterns(workspacePath);
+			let filesToPush;
+			if (paths && paths.length > 0) filesToPush = filterIgnored(paths, ignorePatterns);
+			else filesToPush = await detectLocalChanges(workspacePath, ignorePatterns);
+			if (filter) filesToPush = filesToPush.filter((p) => p.startsWith(filter));
+			if (filesToPush.length === 0) {
+				if (!quiet) log.info("Nothing to push");
+				return {
+					pushed: 0,
+					pulled: 0,
+					conflicts: 0,
+					errors: 0
+				};
+			}
+			if (!quiet) log.info(`Pushing ${String(filesToPush.length)} file(s)`);
+			const results = await uploadFiles(workspacePath, filesToPush, client, { quiet });
+			const pushed = results.filter((r) => r.success).length;
+			const errors = results.filter((r) => !r.success).length;
+			if (!quiet) log.info(`Push complete: ${String(pushed)} uploaded, ${String(errors)} failed`);
+			return {
+				pushed,
+				pulled: 0,
+				conflicts: 0,
+				errors
+			};
+		},
+		async pull(options = {}) {
+			const { quiet = false } = options;
+			const [localManifest, remoteManifest] = await Promise.all([readManifest(workspacePath), client.getManifest()]);
+			const diff = diffManifests(localManifest, remoteManifest);
+			const filesToPull = [...diff.toPull];
+			if (filesToPull.length === 0) {
+				if (!quiet) log.info("Nothing to pull");
+				return {
+					pushed: 0,
+					pulled: 0,
+					conflicts: diff.conflicts.length,
+					errors: 0
+				};
+			}
+			if (!quiet) log.info(`Pulling ${String(filesToPull.length)} file(s)`);
+			const results = await downloadFiles(workspacePath, filesToPull, client, remoteManifest, { quiet });
+			const pulled = results.filter((r) => r.success).length;
+			const errors = results.filter((r) => !r.success).length;
+			if (!quiet) log.info(`Pull complete: ${String(pulled)} downloaded, ${String(errors)} failed`);
+			return {
+				pushed: 0,
+				pulled,
+				conflicts: diff.conflicts.length,
+				errors
+			};
+		},
+		async fullSync(options = {}) {
+			const { quiet = false } = options;
+			const [localManifest, remoteManifest] = await Promise.all([readManifest(workspacePath), client.getManifest()]);
+			const ignorePatterns = await loadIgnorePatterns(workspacePath);
+			const localChanges = await detectLocalChanges(workspacePath, ignorePatterns);
+			const diff = diffManifests(localManifest, remoteManifest);
+			const trueConflicts = diff.conflicts.filter((p) => localChanges.includes(p));
+			const remoteOnlyChanges = diff.conflicts.filter((p) => !localChanges.includes(p));
+			let conflictCount = 0;
+			for (const conflictPath of trueConflicts) {
+				const absolutePath = join(workspacePath, conflictPath);
+				if (existsSync(absolutePath)) {
+					const ext = extname(conflictPath);
+					const base = basename(conflictPath, ext);
+					const dir = dirname(conflictPath);
+					const conflictName = `${base}.conflict-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}${ext}`;
+					await writeFile(join(workspacePath, dir, conflictName), await readFile(absolutePath));
+					if (!quiet) log.warn(`Conflict: ${conflictPath} — saved as ${conflictName}`);
+					conflictCount++;
+				}
+			}
+			const filesToPush = filterIgnored([...diff.toPush, ...localChanges.filter((p) => !diff.conflicts.includes(p))], ignorePatterns);
+			const filesToPull = [
+				...diff.toPull,
+				...remoteOnlyChanges,
+				...trueConflicts
+			];
+			const pushResult = {
+				pushed: 0,
+				errors: 0
+			};
+			const pullResult = {
+				pulled: 0,
+				errors: 0
+			};
+			if (filesToPush.length > 0) {
+				if (!quiet) log.info(`Pushing ${String(filesToPush.length)} file(s)`);
+				const results = await uploadFiles(workspacePath, [...new Set(filesToPush)], client, { quiet });
+				pushResult.pushed = results.filter((r) => r.success).length;
+				pushResult.errors = results.filter((r) => !r.success).length;
+			}
+			if (filesToPull.length > 0) {
+				if (!quiet) log.info(`Pulling ${String(filesToPull.length)} file(s)`);
+				const results = await downloadFiles(workspacePath, filesToPull, client, remoteManifest, { quiet });
+				pullResult.pulled = results.filter((r) => r.success).length;
+				pullResult.errors = results.filter((r) => !r.success).length;
+			}
+			const totalErrors = pushResult.errors + pullResult.errors;
+			if (!quiet) log.info(`Sync complete: ${String(pushResult.pushed)} pushed, ${String(pullResult.pulled)} pulled, ${String(conflictCount)} conflicts, ${String(totalErrors)} errors`);
+			return {
+				pushed: pushResult.pushed,
+				pulled: pullResult.pulled,
+				conflicts: conflictCount,
+				errors: totalErrors
+			};
+		},
+		async pullFiles(paths, options = {}) {
+			const { quiet = false } = options;
+			if (paths.length === 0) return {
+				pushed: 0,
+				pulled: 0,
+				conflicts: 0,
+				errors: 0
+			};
+			const remoteManifest = await client.getManifest();
+			const localManifest = await readManifest(workspacePath);
+			const filesToPull = paths.filter((p) => {
+				if (!(p in remoteManifest.files)) return false;
+				const remoteEntry = remoteManifest.files[p];
+				if (!(p in localManifest.files)) return true;
+				return localManifest.files[p].hash !== remoteEntry.hash;
+			});
+			if (filesToPull.length === 0) {
+				if (!quiet) log.info("All notified files already in sync");
+				return {
+					pushed: 0,
+					pulled: 0,
+					conflicts: 0,
+					errors: 0
+				};
+			}
+			if (!quiet) log.info(`Pulling ${String(filesToPull.length)} changed file(s)`);
+			const results = await downloadFiles(workspacePath, filesToPull, client, remoteManifest, { quiet });
+			const pulled = results.filter((r) => r.success).length;
+			const errors = results.filter((r) => !r.success).length;
+			if (!quiet) log.info(`Pull complete: ${String(pulled)} downloaded, ${String(errors)} failed`);
+			return {
+				pushed: 0,
+				pulled,
+				conflicts: 0,
+				errors
+			};
+		},
+		async removeLocalFile(filePath, options = {}) {
+			const { quiet = false } = options;
+			const absolutePath = join(workspacePath, filePath);
+			try {
+				const { unlink } = await import("node:fs/promises");
+				if (existsSync(absolutePath)) {
+					await unlink(absolutePath);
+					if (!quiet) log.info(`Deleted: ${filePath}`);
+				}
+			} catch (err) {
+				if (!quiet) log.error({ err }, `Failed to delete ${filePath}`);
+			}
+			await removeManifestEntry(workspacePath, filePath);
+		}
+	};
+}
+/**
+* Detect files that have changed locally since last sync.
+*
+* Compares current file hashes against the local manifest.
+* Returns list of relative paths that need pushing.
+*/
+async function detectLocalChanges(workspacePath, ignorePatterns) {
+	const manifest = await readManifest(workspacePath);
+	const changed = [];
+	const { readdir } = await import("node:fs/promises");
+	async function walk(dir) {
+		const entries = await readdir(dir, { withFileTypes: true });
+		for (const entry of entries) {
+			const fullPath = join(dir, entry.name);
+			const relativePath = fullPath.slice(workspacePath.length + 1).replace(/\\/g, "/");
+			if (shouldSkipDir(entry.name)) continue;
+			if (entry.isDirectory()) {
+				if (!ignorePatterns.some((p) => {
+					if (p.endsWith("/**")) return relativePath.startsWith(p.slice(0, -3));
+					return false;
+				})) await walk(fullPath);
+			} else if (entry.isFile()) {
+				const { shouldIgnore } = await import("./ignore.js").then((n) => n.n);
+				if (shouldIgnore(relativePath, ignorePatterns)) continue;
+				if (!(relativePath in manifest.files)) changed.push(relativePath);
+				else {
+					const manifestEntry = manifest.files[relativePath];
+					try {
+						if (await computeFileHash(fullPath) !== manifestEntry.hash) changed.push(relativePath);
+					} catch {}
+				}
+			}
+		}
+	}
+	await walk(workspacePath);
+	return changed;
+}
+/**
+* Directories to always skip during walks.
+*/
+function shouldSkipDir(name) {
+	return name === "node_modules" || name === ".git" || name === ".sst" || name === ".alfesync" || name === ".build" || name === "dist";
+}
+//#endregion
+export { computeFileHash as a, removeManifestEntry as c, configDir as d, configPath as f, writeConfig as g, requireConfig as h, createApiClient as i, updateManifestEntry as l, readConfig as m, downloadFiles as n, diffManifests as o, isInitialized as p, uploadFiles as r, readManifest as s, createSyncEngine as t, writeManifest as u };
+
+//# sourceMappingURL=sync-engine.js.map