@alfe.ai/openclaw-sync 0.0.16 → 0.0.17

package/dist/sync-engine.js

@@ -1,112 +1,10 @@
-import { r as loadIgnorePatterns, t as filterIgnored } from "./ignore.js";
-import { basename, dirname, extname, join } from "node:path";
-import { homedir } from "node:os";
-import { createReadStream, existsSync } from "node:fs";
-import { configExists, resolveConfig } from "@alfe.ai/config";
 import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import { createReadStream, existsSync } from "node:fs";
 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.
-*
-* 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 = join(join(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 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 (!configExists()) return null;
-	let alfe;
-	try {
-		alfe = 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 (!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 })
-		});
-		if (!res.ok) return null;
-		return await res.json();
-	} catch {
-		return null;
-	}
-}
-//#endregion
 //#region src/manifest.ts
 /**
 * AlfeSync manifest — local file manifest at `~/.alfe/sync/manifest.json`.
@@ -119,13 +17,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 = join(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 join(syncStateDir(), MANIFEST_FILE);
+	return join(SYNC_STATE_DIR, MANIFEST_FILE);
 }
 /**
 * Read the local manifest. Returns empty manifest if not found.
@@ -150,7 +54,7 @@ async function readManifest(workspacePath) {
 */
 async function writeManifest(workspacePath, manifest) {
 	const path = manifestPath();
-	await mkdir(syncStateDir(), { recursive: true });
+	await mkdir(SYNC_STATE_DIR, { recursive: true });
 	await writeFile(path, JSON.stringify(manifest, null, 2) + "\n", "utf-8");
 }
 /**
@@ -216,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";
@@ -336,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)})`);
@@ -408,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)})`);
@@ -483,38 +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. 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 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");
@@ -539,10 +409,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 +420,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,7 +434,7 @@ async function createSyncEngine(workspacePathOverride) {
 		},
 		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);
@@ -574,15 +443,14 @@ async function createSyncEngine(workspacePathOverride) {
 			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 = [
@@ -627,13 +495,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 +540,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,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 === ".build" || name === "dist";
 }
 //#endregion
-export { computeFileHash as a, removeManifestEntry as c, invalidateSyncConfigCache as d, isInitialized as f, syncStateDir as h, createApiClient as i, updateManifestEntry as l, resolveSyncConfig as m, downloadFiles as n, diffManifests as o, requireConfig 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