@alfe.ai/openclaw-sync 0.0.15 → 0.0.17

package/dist/sync-engine.js

@@ -1,96 +1,45 @@
-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 { basename, dirname, extname, join } from "node:path";
+import { homedir } from "node:os";
+import micromatch from "micromatch";
 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`.
+* AlfeSync manifest — local file manifest at `~/.alfe/sync/manifest.json`.
 *
 * Tracks file hashes, sizes, sync timestamps, and storage classes
-* to enable efficient diff-based syncing.
+* to enable efficient diff-based syncing. Lives under `~/.alfe/sync/`
+* so workspace directories stay clean.
+*
+* `workspacePath` is accepted by every function for consistency with the
+* rest of the package, but the manifest itself is workspace-independent
+* (one agent, one workspace, one manifest).
+*/
+/**
+* Local state directory for sync — manifest, etc. Lives under `~/.alfe/sync/`
+* so it stays alongside the rest of Alfe's agent state instead of polluting
+* the workspace.
 */
+const SYNC_STATE_DIR = join(homedir(), ".alfe", "sync");
 const MANIFEST_FILE = "manifest.json";
 /**
-* Resolve the manifest file path for a given workspace root.
+* Resolve the manifest file path. Lives under `~/.alfe/sync/`, independent
+* of the workspace path — one agent has one manifest.
 */
-function manifestPath(workspacePath) {
-	return join(configDir(workspacePath), MANIFEST_FILE);
+function manifestPath() {
+	return join(SYNC_STATE_DIR, MANIFEST_FILE);
 }
 /**
 * Read the local manifest. Returns empty manifest if not found.
+*
+* `workspacePath` is accepted for call-site symmetry with the rest of the
+* package but is not used — the manifest path is resolved from
+* `~/.alfe/sync/` regardless of which workspace the call comes from.
 */
 async function readManifest(workspacePath) {
-	const path = manifestPath(workspacePath);
+	const path = manifestPath();
 	if (!existsSync(path)) return { files: {} };
 	try {
 		const raw = await readFile(path, "utf-8");
@@ -100,11 +49,13 @@ async function readManifest(workspacePath) {
 	}
 }
 /**
-* Write the local manifest.
+* Write the local manifest. `workspacePath` is accepted for call-site
+* symmetry but unused (see `readManifest`).
 */
 async function writeManifest(workspacePath, manifest) {
-	await mkdir(configDir(workspacePath), { recursive: true });
-	await writeFile(manifestPath(workspacePath), JSON.stringify(manifest, null, 2) + "\n", "utf-8");
+	const path = manifestPath();
+	await mkdir(SYNC_STATE_DIR, { recursive: true });
+	await writeFile(path, JSON.stringify(manifest, null, 2) + "\n", "utf-8");
 }
 /**
 * Update a single file entry in the local manifest.
@@ -169,118 +120,100 @@ function diffManifests(local, remote) {
 	};
 }
 //#endregion
-//#region src/api-client.ts
+//#region src/ignore.ts
 /**
-* Create an AlfeSync API client.
+* AlfeSync ignore — parse `.alfesyncignore` (gitignore-style glob matching).
+*
+* Uses micromatch for glob pattern matching, compatible with .gitignore syntax.
 */
-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}`);
+/** Default ignore patterns — always applied */
+const DEFAULT_IGNORES = [
+	".alfesync/**",
+	"node_modules/**",
+	"*.tmp",
+	".DS_Store",
+	".git/**",
+	".sst/**",
+	".build/**",
+	"dist/**"
+];
+/**
+* Load ignore patterns from `.alfesyncignore` file + defaults.
+*/
+async function loadIgnorePatterns(workspacePath) {
+	const ignoreFile = join(workspacePath, ".alfesyncignore");
+	const patterns = [...DEFAULT_IGNORES];
+	if (existsSync(ignoreFile)) try {
+		const lines = (await readFile(ignoreFile, "utf-8")).split("\n");
+		for (const line of lines) {
+			const trimmed = line.trim();
+			if (!trimmed || trimmed.startsWith("#")) continue;
+			patterns.push(trimmed);
 		}
-		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 });
+	} catch {}
+	return patterns;
+}
+/**
+* Check if a relative path should be ignored.
+*/
+function shouldIgnore(relativePath, patterns) {
+	return micromatch.isMatch(relativePath, patterns, {
+		dot: true,
+		matchBase: true
+	});
+}
+/**
+* Filter a list of relative paths, removing ignored ones.
+*/
+function filterIgnored(paths, patterns) {
+	return paths.filter((p) => !shouldIgnore(p, patterns));
+}
+//#endregion
+//#region src/retry.ts
+/**
+* Tiny retry helper used by uploader/downloader. Extracted so both
+* use the same timing and surface the same final error shape.
+*/
+const DEFAULT_MAX_RETRIES = 3;
+const DEFAULT_BASE_DELAY_MS = 1e3;
+/**
+* Run `fn` up to `maxRetries + 1` times with exponential backoff
+* (`base * 2^attempt`). Returns the first successful value, or rethrows
+* the last error.
+*/
+async function withRetry(fn, options = {}) {
+	const maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
+	const baseDelayMs = options.baseDelayMs ?? DEFAULT_BASE_DELAY_MS;
+	let lastError;
+	for (let attempt = 0; attempt <= maxRetries; attempt++) try {
+		return await fn();
+	} catch (err) {
+		lastError = err;
+		if (attempt < maxRetries) {
+			const delay = baseDelayMs * Math.pow(2, attempt);
+			await new Promise((resolve) => setTimeout(resolve, delay));
 		}
-	};
+	}
+	throw lastError instanceof Error ? lastError : new Error(String(lastError));
 }
 //#endregion
 //#region src/uploader.ts
 /**
-* AlfeSync uploader — upload changed files to S3 via presigned URLs.
+* AlfeSync uploader — push changed files to S3.
 *
-* 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
+* Per file:
+*   1. Ask the agent API for a presigned PUT URL
+*   2. PUT bytes directly to S3 (raw fetch — S3 isn't an Alfe API)
+*   3. Tell the agent API the upload completed (`syncConfirmUpload`)
+*   4. Update the local manifest
 *
-* Retries 3x with exponential backoff on transient failures.
+* Each step retries with exponential backoff via `withRetry`.
 */
 const log$2 = createLogger("SyncUploader");
-const MAX_RETRIES$1 = 3;
-const BASE_DELAY_MS$1 = 1e3;
-/**
-* Determine the storage class based on file path.
-*/
+const ARCHIVE_PREFIXES = ["sessions/archive/", "context/archive/"];
 function getStorageClass(relativePath) {
-	return relativePath.startsWith("sessions/archive/") || relativePath.startsWith("context/archive/") ? "GLACIER_IR" : "STANDARD";
+	return ARCHIVE_PREFIXES.some((p) => relativePath.startsWith(p)) ? "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";
@@ -289,62 +222,63 @@ function getContentType(relativePath) {
 	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) {
+async function uploadOne(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
+	try {
+		return await withRetry(async () => {
+			const [hash, fileStat] = await Promise.all([computeFileHash(absolutePath), stat(absolutePath)]);
+			const size = fileStat.size;
+			const storageClass = getStorageClass(relativePath);
+			const contentType = getContentType(relativePath);
+			const url = (await client.syncPresign({ files: [{
+				path: relativePath,
+				operation: "put",
+				contentType
+			}] })).urls[0]?.url;
+			if (!url) throw new Error("No presigned URL returned");
+			const fileContent = await readFile(absolutePath);
+			const putResponse = await fetch(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.syncConfirmUpload({
+				filePath: 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) {
 		return {
 			path: relativePath,
-			success: true,
-			hash,
-			size
+			success: false,
+			error: err instanceof Error ? err.message : String(err)
 		};
-	} 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.
+* Upload many files, batched by `concurrency`.
 */
 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)));
+		const batchResults = await Promise.all(batch.map((path) => uploadOne(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)})`);
@@ -361,65 +295,55 @@ function formatBytes$1(bytes) {
 //#endregion
 //#region src/downloader.ts
 /**
-* AlfeSync downloader — download files from S3 via presigned URLs.
+* AlfeSync downloader — pull files from S3 to disk.
 *
-* 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
+* Per file:
+*   1. Ask the agent API for a presigned GET URL
+*   2. GET bytes directly from S3 (raw fetch — S3 isn't an Alfe API)
+*   3. Write to disk
+*   4. Update the 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"
+async function downloadOne(workspacePath, relativePath, client, remoteEntry) {
+	try {
+		return await withRetry(async () => {
+			const url = (await client.syncPresign({ files: [{
+				path: relativePath,
+				operation: "get"
+			}] })).urls[0]?.url;
+			if (!url) throw new Error("No presigned URL returned");
+			const response = await fetch(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) {
 		return {
 			path: relativePath,
-			success: true,
-			size: buffer.length
+			success: false,
+			error: err instanceof Error ? err.message : String(err)
 		};
-	} 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])));
+		const batchResults = await Promise.all(batch.map((path) => downloadOne(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)})`);
@@ -436,36 +360,31 @@ function formatBytes(bytes) {
 //#endregion
 //#region src/sync-engine.ts
 /**
-* AlfeSync engine — orchestrates push, pull, and full sync operations.
+* AlfeSync engine — orchestrates push, pull, and full sync.
 *
-* 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.
+* Conflict resolution: when a remote file is newer than the local manifest
+* entry AND the local file has also changed, the local copy is renamed to
+* `<name>.conflict-<timestamp>.<ext>` and the remote version wins.
 */
 const log = createLogger("SyncEngine");
 /**
-* Create a sync engine for a workspace.
+* Construct a sync engine bound to a workspace + agent API client.
+*
+* The client is constructed once in plugin.ts (or the CLI) and passed in,
+* so credentials never leak into multiple places.
 */
-async function createSyncEngine(workspacePath) {
-	const config = await requireConfig(workspacePath);
-	const client = createApiClient({
-		apiUrl: config.apiUrl,
-		token: config.token,
-		agentId: config.agentId
-	});
+function createSyncEngine({ workspacePath, client }) {
 	return {
-		config,
+		workspacePath,
 		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);
+			let filesToPush = paths && paths.length > 0 ? filterIgnored(paths, ignorePatterns) : await detectLocalChanges(workspacePath, ignorePatterns);
 			if (filter) filesToPush = filesToPush.filter((p) => p.startsWith(filter));
 			if (filesToPush.length === 0) {
 				if (!quiet) log.info("Nothing to push");
@@ -490,10 +409,9 @@ async function createSyncEngine(workspacePath) {
 		},
 		async pull(options = {}) {
 			const { quiet = false } = options;
-			const [localManifest, remoteManifest] = await Promise.all([readManifest(workspacePath), client.getManifest()]);
+			const [localManifest, remoteManifest] = await Promise.all([readManifest(workspacePath), client.syncGetManifest()]);
 			const diff = diffManifests(localManifest, remoteManifest);
-			const filesToPull = [...diff.toPull];
-			if (filesToPull.length === 0) {
+			if (diff.toPull.length === 0) {
 				if (!quiet) log.info("Nothing to pull");
 				return {
 					pushed: 0,
@@ -502,8 +420,8 @@ async function createSyncEngine(workspacePath) {
 					errors: 0
 				};
 			}
-			if (!quiet) log.info(`Pulling ${String(filesToPull.length)} file(s)`);
-			const results = await downloadFiles(workspacePath, filesToPull, client, remoteManifest, { quiet });
+			if (!quiet) log.info(`Pulling ${String(diff.toPull.length)} file(s)`);
+			const results = await downloadFiles(workspacePath, [...diff.toPull], 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`);
@@ -516,7 +434,7 @@ async function createSyncEngine(workspacePath) {
 		},
 		async fullSync(options = {}) {
 			const { quiet = false } = options;
-			const [localManifest, remoteManifest] = await Promise.all([readManifest(workspacePath), client.getManifest()]);
+			const [localManifest, remoteManifest] = await Promise.all([readManifest(workspacePath), client.syncGetManifest()]);
 			const ignorePatterns = await loadIgnorePatterns(workspacePath);
 			const localChanges = await detectLocalChanges(workspacePath, ignorePatterns);
 			const diff = diffManifests(localManifest, remoteManifest);
@@ -525,15 +443,14 @@ async function createSyncEngine(workspacePath) {
 			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++;
-				}
+				if (!existsSync(absolutePath)) continue;
+				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 = [
@@ -578,13 +495,12 @@ async function createSyncEngine(workspacePath) {
 				conflicts: 0,
 				errors: 0
 			};
-			const remoteManifest = await client.getManifest();
+			const remoteManifest = await client.syncGetManifest();
 			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;
+				return localManifest.files[p].hash !== remoteManifest.files[p].hash;
 			});
 			if (filesToPull.length === 0) {
 				if (!quiet) log.info("All notified files already in sync");
@@ -624,10 +540,8 @@ async function createSyncEngine(workspacePath) {
 	};
 }
 /**
-* 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.
+* Walk the workspace and return paths whose hash differs from the manifest
+* (or that are missing from it entirely).
 */
 async function detectLocalChanges(workspacePath, ignorePatterns) {
 	const manifest = await readManifest(workspacePath);
@@ -640,33 +554,27 @@ async function detectLocalChanges(workspacePath, ignorePatterns) {
 			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);
+				if (!ignorePatterns.some((p) => p.endsWith("/**") && relativePath.startsWith(p.slice(0, -3)))) 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 {}
+				if (!(relativePath in manifest.files)) {
+					changed.push(relativePath);
+					continue;
 				}
+				try {
+					if (await computeFileHash(fullPath) !== manifest.files[relativePath].hash) changed.push(relativePath);
+				} catch {}
 			}
 		}
 	}
 	await walk(workspacePath);
 	return changed;
 }
-/**
-* Directories to always skip during walks.
-*/
+/** Directories the engine never descends into. */
 function shouldSkipDir(name) {
-	return name === "node_modules" || name === ".git" || name === ".sst" || name === ".alfesync" || name === ".build" || name === "dist";
+	return name === "node_modules" || name === ".git" || name === ".sst" || 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 };
+export { filterIgnored as a, computeFileHash as c, removeManifestEntry as d, updateManifestEntry as f, withRetry as i, diffManifests as l, downloadFiles as n, loadIgnorePatterns as o, writeManifest as p, uploadFiles as r, shouldIgnore as s, createSyncEngine as t, readManifest as u };
 
 //# sourceMappingURL=sync-engine.js.map