@alfe.ai/openclaw-sync 0.0.15 → 0.0.17

package/dist/sync-engine.cjs

@@ -1,96 +1,68 @@
-const require_ignore = require("./ignore.cjs");
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
 let node_fs_promises = require("node:fs/promises");
 let node_fs = require("node:fs");
-let node_path = require("node:path");
 let node_crypto = require("node:crypto");
+let node_path = require("node:path");
+let node_os = require("node:os");
+let micromatch = require("micromatch");
+micromatch = __toESM(micromatch);
 let _auriclabs_logger = require("@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 (0, node_path.join)(workspacePath, CONFIG_DIR);
-}
-/**
-* Resolve the config file path for a given workspace root.
-*/
-function configPath(workspacePath) {
-	return (0, node_path.join)(workspacePath, CONFIG_DIR, CONFIG_FILE);
-}
-/**
-* Check if a workspace has been initialized with AlfeSync.
-*/
-function isInitialized(workspacePath) {
-	return (0, node_fs.existsSync)(configPath(workspacePath));
-}
-/**
-* Read the AlfeSync config from a workspace.
-* Returns null if not initialized.
-*/
-async function readConfig(workspacePath) {
-	const path = configPath(workspacePath);
-	if (!(0, node_fs.existsSync)(path)) return null;
-	try {
-		const raw = await (0, node_fs_promises.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 (0, node_fs_promises.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 (0, node_fs_promises.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 = (0, node_path.join)((0, node_os.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 (0, node_path.join)(configDir(workspacePath), MANIFEST_FILE);
+function manifestPath() {
+	return (0, node_path.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 (!(0, node_fs.existsSync)(path)) return { files: {} };
 	try {
 		const raw = await (0, node_fs_promises.readFile)(path, "utf-8");
@@ -100,11 +72,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 (0, node_fs_promises.mkdir)(configDir(workspacePath), { recursive: true });
-	await (0, node_fs_promises.writeFile)(manifestPath(workspacePath), JSON.stringify(manifest, null, 2) + "\n", "utf-8");
+	const path = manifestPath();
+	await (0, node_fs_promises.mkdir)(SYNC_STATE_DIR, { recursive: true });
+	await (0, node_fs_promises.writeFile)(path, JSON.stringify(manifest, null, 2) + "\n", "utf-8");
 }
 /**
 * Update a single file entry in the local manifest.
@@ -169,118 +143,100 @@ function diffManifests(local, remote) {
 	};
 }
 //#endregion
-//#region src/api-client.ts
+//#region src/ignore.ts
+/**
+* AlfeSync ignore — parse `.alfesyncignore` (gitignore-style glob matching).
+*
+* Uses micromatch for glob pattern matching, compatible with .gitignore syntax.
+*/
+/** Default ignore patterns — always applied */
+const DEFAULT_IGNORES = [
+	".alfesync/**",
+	"node_modules/**",
+	"*.tmp",
+	".DS_Store",
+	".git/**",
+	".sst/**",
+	".build/**",
+	"dist/**"
+];
 /**
-* Create an AlfeSync API client.
+* Load ignore patterns from `.alfesyncignore` file + defaults.
 */
-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}`);
+async function loadIgnorePatterns(workspacePath) {
+	const ignoreFile = (0, node_path.join)(workspacePath, ".alfesyncignore");
+	const patterns = [...DEFAULT_IGNORES];
+	if ((0, node_fs.existsSync)(ignoreFile)) try {
+		const lines = (await (0, node_fs_promises.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.default.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 = (0, _auriclabs_logger.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 +245,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 = (0, node_path.join)(workspacePath, relativePath);
-	let lastError;
-	for (let attempt = 0; attempt <= MAX_RETRIES$1; attempt++) try {
-		const [hash, fileStat] = await Promise.all([computeFileHash(absolutePath), (0, node_fs_promises.stat)(absolutePath)]);
-		const size = fileStat.size;
-		const storageClass = getStorageClass(relativePath);
-		const contentType = getContentType(relativePath);
-		const presigned = await client.presignPut(relativePath, contentType);
-		const fileContent = await (0, node_fs_promises.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), (0, node_fs_promises.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 (0, node_fs_promises.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 +318,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 = (0, _auriclabs_logger.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 = (0, node_path.join)(workspacePath, relativePath);
-		await (0, node_fs_promises.mkdir)((0, node_path.dirname)(absolutePath), { recursive: true });
-		await (0, node_fs_promises.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 = (0, node_path.join)(workspacePath, relativePath);
+			await (0, node_fs_promises.mkdir)((0, node_path.dirname)(absolutePath), { recursive: true });
+			await (0, node_fs_promises.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 +383,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 = (0, _auriclabs_logger.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 require_ignore.loadIgnorePatterns(workspacePath);
-			let filesToPush;
-			if (paths && paths.length > 0) filesToPush = require_ignore.filterIgnored(paths, ignorePatterns);
-			else filesToPush = await detectLocalChanges(workspacePath, ignorePatterns);
+			const ignorePatterns = await loadIgnorePatterns(workspacePath);
+			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 +432,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 +443,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,8 +457,8 @@ async function createSyncEngine(workspacePath) {
 		},
 		async fullSync(options = {}) {
 			const { quiet = false } = options;
-			const [localManifest, remoteManifest] = await Promise.all([readManifest(workspacePath), client.getManifest()]);
-			const ignorePatterns = await require_ignore.loadIgnorePatterns(workspacePath);
+			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);
 			const trueConflicts = diff.conflicts.filter((p) => localChanges.includes(p));
@@ -525,17 +466,16 @@ async function createSyncEngine(workspacePath) {
 			let conflictCount = 0;
 			for (const conflictPath of trueConflicts) {
 				const absolutePath = (0, node_path.join)(workspacePath, conflictPath);
-				if ((0, node_fs.existsSync)(absolutePath)) {
-					const ext = (0, node_path.extname)(conflictPath);
-					const base = (0, node_path.basename)(conflictPath, ext);
-					const dir = (0, node_path.dirname)(conflictPath);
-					const conflictName = `${base}.conflict-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}${ext}`;
-					await (0, node_fs_promises.writeFile)((0, node_path.join)(workspacePath, dir, conflictName), await (0, node_fs_promises.readFile)(absolutePath));
-					if (!quiet) log.warn(`Conflict: ${conflictPath} — saved as ${conflictName}`);
-					conflictCount++;
-				}
+				if (!(0, node_fs.existsSync)(absolutePath)) continue;
+				const ext = (0, node_path.extname)(conflictPath);
+				const base = (0, node_path.basename)(conflictPath, ext);
+				const dir = (0, node_path.dirname)(conflictPath);
+				const conflictName = `${base}.conflict-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}${ext}`;
+				await (0, node_fs_promises.writeFile)((0, node_path.join)(workspacePath, dir, conflictName), await (0, node_fs_promises.readFile)(absolutePath));
+				if (!quiet) log.warn(`Conflict: ${conflictPath} — saved as ${conflictName}`);
+				conflictCount++;
 			}
-			const filesToPush = require_ignore.filterIgnored([...diff.toPush, ...localChanges.filter((p) => !diff.conflicts.includes(p))], ignorePatterns);
+			const filesToPush = filterIgnored([...diff.toPush, ...localChanges.filter((p) => !diff.conflicts.includes(p))], ignorePatterns);
 			const filesToPull = [
 				...diff.toPull,
 				...remoteOnlyChanges,
@@ -578,13 +518,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 +563,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,55 +577,37 @@ 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 Promise.resolve().then(() => require("./ignore.cjs")).then((n) => n.ignore_exports);
 				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
-Object.defineProperty(exports, "computeFileHash", {
-	enumerable: true,
-	get: function() {
-		return computeFileHash;
-	}
-});
-Object.defineProperty(exports, "configDir", {
+Object.defineProperty(exports, "__toESM", {
 	enumerable: true,
 	get: function() {
-		return configDir;
+		return __toESM;
 	}
 });
-Object.defineProperty(exports, "configPath", {
-	enumerable: true,
-	get: function() {
-		return configPath;
-	}
-});
-Object.defineProperty(exports, "createApiClient", {
+Object.defineProperty(exports, "computeFileHash", {
 	enumerable: true,
 	get: function() {
-		return createApiClient;
+		return computeFileHash;
 	}
 });
 Object.defineProperty(exports, "createSyncEngine", {
@@ -709,16 +628,16 @@ Object.defineProperty(exports, "downloadFiles", {
 		return downloadFiles;
 	}
 });
-Object.defineProperty(exports, "isInitialized", {
+Object.defineProperty(exports, "filterIgnored", {
 	enumerable: true,
 	get: function() {
-		return isInitialized;
+		return filterIgnored;
 	}
 });
-Object.defineProperty(exports, "readConfig", {
+Object.defineProperty(exports, "loadIgnorePatterns", {
 	enumerable: true,
 	get: function() {
-		return readConfig;
+		return loadIgnorePatterns;
 	}
 });
 Object.defineProperty(exports, "readManifest", {
@@ -733,10 +652,10 @@ Object.defineProperty(exports, "removeManifestEntry", {
 		return removeManifestEntry;
 	}
 });
-Object.defineProperty(exports, "requireConfig", {
+Object.defineProperty(exports, "shouldIgnore", {
 	enumerable: true,
 	get: function() {
-		return requireConfig;
+		return shouldIgnore;
 	}
 });
 Object.defineProperty(exports, "updateManifestEntry", {
@@ -751,10 +670,10 @@ Object.defineProperty(exports, "uploadFiles", {
 		return uploadFiles;
 	}
 });
-Object.defineProperty(exports, "writeConfig", {
+Object.defineProperty(exports, "withRetry", {
 	enumerable: true,
 	get: function() {
-		return writeConfig;
+		return withRetry;
 	}
 });
 Object.defineProperty(exports, "writeManifest", {