@alfe.ai/openclaw-sync 0.0.16 → 0.0.18

package/dist/sync-engine.cjs

@@ -1,112 +1,33 @@
-const require_ignore = require("./ignore.cjs");
-let node_path = require("node:path");
-let node_os = require("node:os");
-let node_fs = require("node:fs");
-let _alfe_ai_config = require("@alfe.ai/config");
-let node_fs_promises = require("node:fs/promises");
-let node_crypto = require("node:crypto");
-let _auriclabs_logger = require("@auriclabs/logger");
-//#region src/config.ts
-/**
-* AlfeSync configuration.
-*
-* Derives credentials from `@alfe.ai/config` (~/.alfe/config.toml) so the
-* sync plugin works on any agent that's already logged in — no separate
-* `.alfesync/config.json` or manual `alfesync init` required.
-*
-* The only field not directly in @alfe.ai/config is `agentId`, which is
-* resolved once at startup by calling POST /auth/validate (same pattern
-* the gateway daemon uses to bootstrap its own identity).
-*/
-const SYNC_STATE_DIR = (0, node_path.join)((0, node_path.join)((0, node_os.homedir)(), ".alfe"), "sync");
-/**
-* In-memory cache — agentId is stable for process lifetime.
-*
-* We cache the *Promise* (not just the resolved value) so that concurrent
-* callers during plugin activation share a single `/auth/validate` round-trip
-* instead of each firing their own.
-*/
-let cachedSyncConfigPromise = null;
-/**
-* Local on-disk state directory (manifest, etc.) — separate from credentials.
-* Lives under ~/.alfe/sync/ so sync state stays alongside the rest of Alfe's
-* agent state, not scattered across the workspace.
-*/
-function syncStateDir() {
-	return SYNC_STATE_DIR;
-}
-/**
-* True if the agent has logged in (~/.alfe/config.toml exists).
-* Sync needs no separate initialization — login is enough.
-*/
-function isInitialized() {
-	return (0, _alfe_ai_config.configExists)();
-}
-/**
-* Invalidate the in-memory config cache. Call after login changes.
-*/
-function invalidateSyncConfigCache() {
-	cachedSyncConfigPromise = null;
-}
-/**
-* Resolve the full sync config — apiKey + apiUrl from @alfe.ai/config,
-* agentId/orgId fetched once from /auth/validate.
-*
-* Returns null if the agent isn't logged in or validation fails.
-* Callers that require config should use requireConfig().
-*
-* Concurrent callers share a single in-flight promise; failures are
-* not cached so a transient API blip doesn't poison the process.
-*/
-async function resolveSyncConfig() {
-	if (cachedSyncConfigPromise) return cachedSyncConfigPromise;
-	const promise = doResolveSyncConfig();
-	cachedSyncConfigPromise = promise;
-	const result = await promise;
-	if (result === null) cachedSyncConfigPromise = null;
-	return result;
-}
-async function doResolveSyncConfig() {
-	if (!(0, _alfe_ai_config.configExists)()) return null;
-	let alfe;
-	try {
-		alfe = (0, _alfe_ai_config.resolveConfig)();
-	} catch {
-		return null;
-	}
-	const validated = await validateToken(alfe.apiUrl, alfe.apiKey);
-	if (!validated?.agentId || !validated.tenantId) return null;
-	return {
-		agentId: validated.agentId,
-		orgId: validated.tenantId,
-		token: alfe.apiKey,
-		workspacePath: alfe.workspacePath,
-		apiUrl: alfe.apiUrl
-	};
-}
-/**
-* Resolve config or throw with a clear message. Use in CLI entry points.
-*/
-async function requireConfig() {
-	if (!(0, _alfe_ai_config.configExists)()) throw new Error("Alfe not configured — run `alfe login` first.");
-	const config = await resolveSyncConfig();
-	if (!config) throw new Error("Failed to resolve sync config — token may be invalid or the API is unreachable.");
-	return config;
-}
-async function validateToken(apiUrl, token) {
-	try {
-		const res = await fetch(`${apiUrl}/auth/validate`, {
-			method: "POST",
-			headers: { "Content-Type": "application/json" },
-			body: JSON.stringify({ token })
+//#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
 		});
-		if (!res.ok) return null;
-		return await res.json();
-	} catch {
-		return null;
 	}
-}
+	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_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/manifest.ts
 /**
 * AlfeSync manifest — local file manifest at `~/.alfe/sync/manifest.json`.
@@ -119,13 +40,19 @@ async function validateToken(apiUrl, token) {
 * 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. Lives under `~/.alfe/sync/`, independent
 * of the workspace path — one agent has one manifest.
 */
 function manifestPath() {
-	return (0, node_path.join)(syncStateDir(), MANIFEST_FILE);
+	return (0, node_path.join)(SYNC_STATE_DIR, MANIFEST_FILE);
 }
 /**
 * Read the local manifest. Returns empty manifest if not found.
@@ -150,7 +77,7 @@ async function readManifest(workspacePath) {
 */
 async function writeManifest(workspacePath, manifest) {
 	const path = manifestPath();
-	await (0, node_fs_promises.mkdir)(syncStateDir(), { recursive: true });
+	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");
 }
 /**
@@ -216,118 +143,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 = (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";
@@ -336,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)})`);
@@ -408,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)})`);
@@ -483,38 +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. Workspace path defaults to `config.workspacePath`
-* from the resolved Alfe config, but can be overridden (e.g. for tests).
+* 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(workspacePathOverride) {
-	const config = await requireConfig();
-	const workspacePath = workspacePathOverride ?? config.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");
@@ -539,10 +432,9 @@ async function createSyncEngine(workspacePathOverride) {
 		},
 		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,
@@ -551,8 +443,8 @@ async function createSyncEngine(workspacePathOverride) {
 					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`);
@@ -565,8 +457,8 @@ async function createSyncEngine(workspacePathOverride) {
 		},
 		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));
@@ -574,17 +466,16 @@ async function createSyncEngine(workspacePathOverride) {
 			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,
@@ -627,13 +518,12 @@ async function createSyncEngine(workspacePathOverride) {
 				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");
@@ -673,10 +563,8 @@ async function createSyncEngine(workspacePathOverride) {
 	};
 }
 /**
-* 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);
@@ -689,43 +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 === ".build" || name === "dist";
 }
 //#endregion
-Object.defineProperty(exports, "computeFileHash", {
+Object.defineProperty(exports, "__toESM", {
 	enumerable: true,
 	get: function() {
-		return computeFileHash;
+		return __toESM;
 	}
 });
-Object.defineProperty(exports, "createApiClient", {
+Object.defineProperty(exports, "computeFileHash", {
 	enumerable: true,
 	get: function() {
-		return createApiClient;
+		return computeFileHash;
 	}
 });
 Object.defineProperty(exports, "createSyncEngine", {
@@ -746,16 +628,16 @@ Object.defineProperty(exports, "downloadFiles", {
 		return downloadFiles;
 	}
 });
-Object.defineProperty(exports, "invalidateSyncConfigCache", {
+Object.defineProperty(exports, "filterIgnored", {
 	enumerable: true,
 	get: function() {
-		return invalidateSyncConfigCache;
+		return filterIgnored;
 	}
 });
-Object.defineProperty(exports, "isInitialized", {
+Object.defineProperty(exports, "loadIgnorePatterns", {
 	enumerable: true,
 	get: function() {
-		return isInitialized;
+		return loadIgnorePatterns;
 	}
 });
 Object.defineProperty(exports, "readManifest", {
@@ -770,22 +652,10 @@ Object.defineProperty(exports, "removeManifestEntry", {
 		return removeManifestEntry;
 	}
 });
-Object.defineProperty(exports, "requireConfig", {
-	enumerable: true,
-	get: function() {
-		return requireConfig;
-	}
-});
-Object.defineProperty(exports, "resolveSyncConfig", {
-	enumerable: true,
-	get: function() {
-		return resolveSyncConfig;
-	}
-});
-Object.defineProperty(exports, "syncStateDir", {
+Object.defineProperty(exports, "shouldIgnore", {
 	enumerable: true,
 	get: function() {
-		return syncStateDir;
+		return shouldIgnore;
 	}
 });
 Object.defineProperty(exports, "updateManifestEntry", {
@@ -800,6 +670,12 @@ Object.defineProperty(exports, "uploadFiles", {
 		return uploadFiles;
 	}
 });
+Object.defineProperty(exports, "withRetry", {
+	enumerable: true,
+	get: function() {
+		return withRetry;
+	}
+});
 Object.defineProperty(exports, "writeManifest", {
 	enumerable: true,
 	get: function() {