@alfe.ai/openclaw-sync 0.2.2 → 0.2.4

package/dist/sync-engine.cjs

@@ -90,6 +90,20 @@ async function updateManifestEntry(workspacePath, relativePath, entry) {
 	await writeManifest(workspacePath, manifest);
 }
 /**
+* Update many file entries in one read-modify-write pass.
+*
+* `updateManifestEntry` re-reads and rewrites the whole manifest JSON per
+* call — fine for single-file watcher events, quadratic for bulk heals, and
+* lossy when calls overlap. Use this for any batch (e.g. the recovery
+* "identical → heal" pass). Optionally stamps the owning agentId.
+*/
+async function updateManifestEntries(workspacePath, entries, options = {}) {
+	const manifest = await readManifest(workspacePath);
+	Object.assign(manifest.files, entries);
+	if (options.agentId) manifest.agentId = options.agentId;
+	await writeManifest(workspacePath, manifest);
+}
+/**
 * Remove a file entry from the local manifest.
 */
 async function removeManifestEntry(workspacePath, relativePath) {
@@ -264,6 +278,12 @@ async function withRetry(fn, options = {}) {
 * Each step retries with exponential backoff via `withRetry`.
 */
 const log$2 = (0, _auriclabs_logger.createLogger)("SyncUploader");
+/**
+* Prefixes stored as GLACIER_IR on the sync bucket. Shared with the recovery
+* classifier in sync-engine.ts, which must never cut conflict sidecars for
+* archive objects (their presigned GETs fail until restored, so hashing/
+* preserving them is wasted work on a pull that can't succeed anyway).
+*/
 const ARCHIVE_PREFIXES = ["sessions/archive/", "context/archive/"];
 function getStorageClass(relativePath) {
 	return ARCHIVE_PREFIXES.some((p) => relativePath.startsWith(p)) ? "GLACIER_IR" : "STANDARD";
@@ -303,17 +323,17 @@ async function uploadOne(workspacePath, relativePath, client) {
 				size,
 				storageClass
 			});
-			await updateManifestEntry(workspacePath, relativePath, {
-				hash,
-				size,
-				lastSynced: (/* @__PURE__ */ new Date()).toISOString(),
-				storageClass
-			});
 			return {
 				path: relativePath,
 				success: true,
 				hash,
-				size
+				size,
+				entry: {
+					hash,
+					size,
+					lastSynced: (/* @__PURE__ */ new Date()).toISOString(),
+					storageClass
+				}
 			};
 		});
 	} catch (err) {
@@ -333,11 +353,20 @@ async function uploadFiles(workspacePath, relativePaths, client, options = {}) {
 	for (let i = 0; i < relativePaths.length; i += concurrency) {
 		const batch = relativePaths.slice(i, i + concurrency);
 		const batchResults = await Promise.all(batch.map((path) => uploadOne(workspacePath, path, client)));
+		const entries = {};
 		for (const result of batchResults) {
-			results.push(result);
+			if (result.entry !== void 0) entries[result.path] = result.entry;
+			results.push({
+				path: result.path,
+				success: result.success,
+				hash: result.hash,
+				size: result.size,
+				error: result.error
+			});
 			if (!quiet) if (result.success) log$2.info(`Uploaded ${result.path} (${formatBytes$1(result.size ?? 0)})`);
 			else log$2.error(`Failed to upload ${result.path}: ${result.error ?? "Unknown error"}`);
 		}
+		if (Object.keys(entries).length > 0) await updateManifestEntries(workspacePath, entries);
 	}
 	return results;
 }
@@ -372,16 +401,17 @@ async function downloadOne(workspacePath, relativePath, client, remoteEntry) {
 			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, {
+			const entry = {
 				hash: remoteEntry?.hash ?? "",
 				size: buffer.length,
 				lastSynced: (/* @__PURE__ */ new Date()).toISOString(),
 				storageClass: remoteEntry?.storageClass ?? "STANDARD"
-			});
+			};
 			return {
 				path: relativePath,
 				success: true,
-				size: buffer.length
+				size: buffer.length,
+				entry
 			};
 		});
 	} catch (err) {
@@ -398,11 +428,19 @@ async function downloadFiles(workspacePath, relativePaths, client, remoteManifes
 	for (let i = 0; i < relativePaths.length; i += concurrency) {
 		const batch = relativePaths.slice(i, i + concurrency);
 		const batchResults = await Promise.all(batch.map((path) => downloadOne(workspacePath, path, client, remoteManifest?.files[path])));
+		const entries = {};
 		for (const result of batchResults) {
-			results.push(result);
+			if (result.entry !== void 0) entries[result.path] = result.entry;
+			results.push({
+				path: result.path,
+				success: result.success,
+				size: result.size,
+				error: result.error
+			});
 			if (!quiet) if (result.success) log$1.info(`Downloaded ${result.path} (${formatBytes(result.size ?? 0)})`);
 			else log$1.error(`Failed to download ${result.path}: ${result.error ?? "Unknown error"}`);
 		}
+		if (Object.keys(entries).length > 0) await updateManifestEntries(workspacePath, entries);
 	}
 	return results;
 }
@@ -426,12 +464,45 @@ function formatBytes(bytes) {
 */
 const log = (0, _auriclabs_logger.createLogger)("SyncEngine");
 /**
+* Above this size a diverged local file is NOT copied to a `.conflict-*`
+* sidecar during recovery (the cloud copy still replaces it). Sidecars
+* double disk usage per file; a multi-GB session archive could fill the VM.
+* The un-preserved overwrite is never silent — it is logged and listed in
+* the RECOVERY report.
+*/
+const MAX_PRESERVE_BYTES = 100 * 1024 * 1024;
+/** Marker that keeps the heartbeat recovery nudge idempotent across runs. */
+const RECOVERY_NUDGE_MARKER = "<!-- alfe-sync:recovery-nudge -->";
+/**
+* Recovery artifacts: `.conflict-<ts>` sidecars and `RECOVERY-<ts>.md`
+* reports. Anchored to the timestamp shape so legitimate user files like
+* `my.conflict-notes.txt` or `RECOVERY-plan.md` are never misclassified.
+*
+* They seed UP to the cloud so a preserved local version survives even if
+* the VM dies before the agent merges it (retrievable via the dashboard
+* file manager), but they are never AUTO-restored back down and never
+* preserved again — restoring would resurrect copies the agent already
+* cleaned up, and re-preserving would cascade `.conflict`-of-`.conflict`
+* files. Cloud copies are reclaimed when the agent's local cleanup
+* propagates through the watcher; artifacts orphaned by a rebuild before
+* cleanup linger until then (accepted: small, user-visible, deletable).
+* The watcher's delete brake also exempts them so the agent's post-merge
+* cleanup of many sidecars can't trip it.
+*
+* Deliberately NOT in the ignore set: ignored paths don't seed up and would
+* be eligible for pruneIgnored deletion.
+*/
+function isRecoveryArtifact(relativePath) {
+	const name = (0, node_path.basename)(relativePath);
+	return /\.conflict-\d{4}-\d{2}-\d{2}T/.test(name) || /^RECOVERY-\d{4}-\d{2}-\d{2}T.*\.md$/.test(name);
+}
+/**
 * 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.
 */
-function createSyncEngine({ workspacePath, client, runtime = "openclaw" }) {
+function createSyncEngine({ workspacePath, client, runtime = "openclaw", maxPreserveBytes = MAX_PRESERVE_BYTES }) {
 	return {
 		workspacePath,
 		client,
@@ -524,15 +595,11 @@ function createSyncEngine({ workspacePath, client, runtime = "openclaw" }) {
 			const trueConflicts = diff.conflicts.filter((p) => localChanges.includes(p));
 			const remoteOnlyChanges = diff.conflicts.filter((p) => !localChanges.includes(p));
 			let conflictCount = 0;
+			const conflictTimestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
 			for (const conflictPath of trueConflicts) {
-				const absolutePath = (0, node_path.join)(workspacePath, conflictPath);
-				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}`);
+				const outcome = await preserveConflictCopy(workspacePath, conflictPath, conflictTimestamp);
+				if (outcome.status === "vanished") continue;
+				if (outcome.status !== "too-large" && !quiet) log.warn(`Conflict: ${conflictPath} — saved as ${outcome.conflictPath}`);
 				conflictCount++;
 			}
 			const filesToPush = filterIgnored([...diff.toPush, ...localChanges.filter((p) => !diff.conflicts.includes(p))], ignorePatterns);
@@ -576,25 +643,104 @@ function createSyncEngine({ workspacePath, client, runtime = "openclaw" }) {
 			const remotePaths = Object.keys(remoteManifest.files);
 			if (remotePaths.length === 0) {
 				if (!quiet) log.info("First-run sync: no cloud state — seeding workspace to cloud");
-				return this.push(void 0, options);
+				const seedResult = await this.push(void 0, options);
+				await updateManifestEntries(workspacePath, {}, { agentId: remoteManifest.agentId });
+				return seedResult;
 			}
 			if (!quiet) log.info(`First-run sync: ${String(remotePaths.length)} file(s) in cloud — restoring cloud state before seeding`);
 			const ignorePatterns = await loadIgnorePatterns(workspacePath, runtime);
-			const restorePaths = filterIgnored(remotePaths, ignorePatterns);
-			const restore = await this.pullFiles(restorePaths, options);
+			const restorePaths = filterIgnored(remotePaths, ignorePatterns).filter((p) => !isRecoveryArtifact(p));
+			const localManifest = await readManifest(workspacePath);
+			const manifestTrusted = localManifest.agentId === void 0 || localManifest.agentId === remoteManifest.agentId;
+			if (!manifestTrusted) {
+				log.warn(`Local sync manifest belongs to agent ${localManifest.agentId ?? "?"} but cloud state is agent ${remoteManifest.agentId} — treating the manifest as lost`);
+				await writeManifest(workspacePath, {
+					files: {},
+					agentId: remoteManifest.agentId
+				});
+			}
+			const classes = await classifyRestorePaths(workspacePath, restorePaths, remoteManifest.files, localManifest, manifestTrusted);
+			for (const p of classes.offlineDeletes) if (!quiet) log.info(`Recovery: ${p} was deleted locally while sync was down — not restoring it`);
+			if (classes.offlineDeletes.length > 0) log.info(`Recovery: ${String(classes.offlineDeletes.length)} locally-deleted file(s) not restored from cloud`);
+			const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+			const preserved = [];
+			let newlyPreserved = 0;
+			for (const { path, diskHash, size } of classes.preserve) {
+				const outcome = await preserveConflictCopy(workspacePath, path, timestamp, {
+					maxBytes: maxPreserveBytes,
+					sourceHash: diskHash
+				});
+				if (outcome.status === "vanished") continue;
+				const record = {
+					path,
+					localHash: diskHash,
+					remoteHash: remoteManifest.files[path].hash,
+					size
+				};
+				if (outcome.status === "too-large") {
+					record.tooLarge = true;
+					newlyPreserved++;
+					log.warn(`Recovery: ${path} diverged locally but exceeds the sidecar size cap — cloud version will replace it WITHOUT a preserved copy`);
+				} else {
+					record.conflictPath = outcome.conflictPath;
+					if (outcome.status === "preserved") newlyPreserved++;
+					log.warn(`Recovery: preserved local ${path} as ${outcome.conflictPath} — cloud version restored in place`);
+				}
+				preserved.push(record);
+			}
+			let recoveryReportPath = null;
+			if (preserved.length > 0 && (newlyPreserved > 0 || !await recoveryReportExists(workspacePath))) {
+				recoveryReportPath = `${agentDirPrefix(workspacePath)}RECOVERY-${timestamp}.md`;
+				const reportAbsolute = (0, node_path.join)(workspacePath, recoveryReportPath);
+				await (0, node_fs_promises.mkdir)((0, node_path.dirname)(reportAbsolute), { recursive: true });
+				await (0, node_fs_promises.writeFile)(reportAbsolute, buildRecoveryReport(preserved, workspacePath), "utf-8");
+				log.warn(`Recovery: ${String(preserved.length)} diverged local file(s) — see ${recoveryReportPath}`);
+			}
+			const pullList = [
+				...classes.missing,
+				...classes.pullClean,
+				...classes.preserve.map((p) => p.path)
+			];
+			const restore = {
+				pulled: 0,
+				errors: 0
+			};
+			if (pullList.length > 0) {
+				if (!quiet) log.info(`Pulling ${String(pullList.length)} file(s)`);
+				const results = await downloadFiles(workspacePath, pullList, client, remoteManifest, options);
+				restore.pulled = results.filter((r) => r.success).length;
+				restore.errors = results.filter((r) => !r.success).length;
+			}
+			if (Object.keys(classes.heal).length > 0 || localManifest.agentId !== remoteManifest.agentId) await updateManifestEntries(workspacePath, classes.heal, { agentId: remoteManifest.agentId });
 			const remoteSet = new Set(remotePaths);
-			const toSeed = (await detectLocalChanges(workspacePath, ignorePatterns)).filter((p) => !remoteSet.has(p));
-			const seed = toSeed.length > 0 ? await this.push(toSeed, options) : {
+			const pushList = [...(await detectLocalChanges(workspacePath, ignorePatterns)).filter((p) => !remoteSet.has(p)), ...classes.localAhead];
+			const seed = pushList.length > 0 ? await this.push(pushList, options) : {
 				pushed: 0,
 				pulled: 0,
 				conflicts: 0,
 				errors: 0
 			};
+			let nudge = {
+				pushed: 0,
+				errors: 0
+			};
+			if (preserved.length > 0 && recoveryReportPath !== null && runtime === "openclaw") try {
+				const nudgePath = await appendRecoveryNudge(workspacePath, recoveryReportPath, preserved.length);
+				if (nudgePath !== null) {
+					const pushResult = await this.push([nudgePath], options);
+					nudge = {
+						pushed: pushResult.pushed,
+						errors: pushResult.errors
+					};
+				}
+			} catch (err) {
+				log.warn(`Recovery: failed to write heartbeat nudge: ${err instanceof Error ? err.message : String(err)}`);
+			}
 			return {
-				pushed: seed.pushed,
+				pushed: seed.pushed + nudge.pushed,
 				pulled: restore.pulled,
-				conflicts: restore.conflicts + seed.conflicts,
-				errors: restore.errors + seed.errors
+				conflicts: preserved.length + seed.conflicts,
+				errors: restore.errors + seed.errors + nudge.errors
 			};
 		},
 		async pullFiles(paths, options = {}) {
@@ -697,6 +843,190 @@ async function detectLocalChanges(workspacePath, ignorePatterns) {
 	await walk(workspacePath);
 	return changed;
 }
+/**
+* Relative prefix of the agent's actual working directory. The sync root is
+* the runtime HOME (`~/.openclaw`), but the agent lives and works in
+* `~/.openclaw/workspace/` — recovery artifacts meant for the agent's eyes
+* (RECOVERY report, heartbeat nudge) must land there or it never sees them.
+* Falls back to the sync root when no `workspace/` dir exists (tests, CLI
+* usage against a bare directory).
+*/
+function agentDirPrefix(workspacePath) {
+	return (0, node_fs.existsSync)((0, node_path.join)(workspacePath, "workspace")) ? "workspace/" : "";
+}
+/** Whether an unresolved RECOVERY-*.md report already sits in the agent dir. */
+async function recoveryReportExists(workspacePath) {
+	return (await (0, node_fs_promises.readdir)((0, node_path.join)(workspacePath, agentDirPrefix(workspacePath))).catch(() => [])).some((name) => name.startsWith("RECOVERY-") && name.endsWith(".md"));
+}
+/**
+* Copy a file aside as `<base>.conflict-<ts><ext>` in the same directory
+* before a remote copy overwrites it. Uses `copyFile` (no buffering — safe
+* for large/binary files).
+*
+* Idempotent: if a sibling sidecar with identical content already exists
+* (crash-loop retry, repeated recovery), no new copy is stacked. Pass
+* `sourceHash` when the caller already hashed the file.
+*/
+async function preserveConflictCopy(workspacePath, relativePath, timestamp, options = {}) {
+	const absolutePath = (0, node_path.join)(workspacePath, relativePath);
+	const ext = (0, node_path.extname)(relativePath);
+	const base = (0, node_path.basename)(relativePath, ext);
+	const dir = (0, node_path.dirname)(relativePath);
+	try {
+		const fileStat = await (0, node_fs_promises.stat)(absolutePath);
+		if (options.maxBytes !== void 0 && fileStat.size > options.maxBytes) return {
+			status: "too-large",
+			size: fileStat.size
+		};
+		const sourceHash = options.sourceHash ?? await computeFileHash(absolutePath);
+		const siblings = await (0, node_fs_promises.readdir)((0, node_path.join)(workspacePath, dir)).catch(() => []);
+		for (const name of siblings) {
+			if (!name.startsWith(`${base}.conflict-`)) continue;
+			if (ext !== "" && !name.endsWith(ext)) continue;
+			if (await computeFileHash((0, node_path.join)(workspacePath, dir, name)).catch(() => null) === sourceHash) return {
+				status: "already-preserved",
+				conflictPath: (0, node_path.join)(dir, name).replace(/\\/g, "/")
+			};
+		}
+		const conflictName = `${base}.conflict-${timestamp}${ext}`;
+		await (0, node_fs_promises.copyFile)(absolutePath, (0, node_path.join)(workspacePath, dir, conflictName));
+		return {
+			status: "preserved",
+			conflictPath: (0, node_path.join)(dir, conflictName).replace(/\\/g, "/")
+		};
+	} catch {
+		return { status: "vanished" };
+	}
+}
+const CLASSIFY_CONCURRENCY = 8;
+/**
+* Classify every cloud-held path for recovery. The destructive decision
+* (overwrite local content) is only ever taken when the DISK hash diverges
+* from the cloud AND the local manifest can't vouch for the disk content —
+* and even then the local bytes are preserved first. The manifest and mtime
+* are used solely to avoid work and to detect local-ahead edits, never to
+* authorize an unpreserved overwrite.
+*/
+async function classifyRestorePaths(workspacePath, restorePaths, remoteFiles, localManifest, manifestTrusted) {
+	const out = {
+		missing: [],
+		offlineDeletes: [],
+		heal: {},
+		pullClean: [],
+		localAhead: [],
+		preserve: []
+	};
+	async function classifyOne(path) {
+		const remote = remoteFiles[path];
+		const entry = manifestTrusted ? localManifest.files[path] : void 0;
+		const absolutePath = (0, node_path.join)(workspacePath, path);
+		let fileStat = null;
+		try {
+			fileStat = await (0, node_fs_promises.stat)(absolutePath);
+		} catch {}
+		if (!fileStat?.isFile()) {
+			if (entry?.hash === remote.hash) out.offlineDeletes.push(path);
+			else out.missing.push(path);
+			return;
+		}
+		const unchangedSinceSync = fileStat.size === entry?.size && fileStat.mtimeMs <= Date.parse(entry.lastSynced);
+		const isArchive = ARCHIVE_PREFIXES.some((p) => path.startsWith(p));
+		if (unchangedSinceSync || isArchive) {
+			if (entry?.hash === remote.hash) return;
+			out.pullClean.push(path);
+			return;
+		}
+		let diskHash;
+		try {
+			diskHash = await computeFileHash(absolutePath);
+		} catch {
+			out.missing.push(path);
+			return;
+		}
+		if (diskHash === remote.hash) {
+			if (entry?.hash !== remote.hash) out.heal[path] = {
+				hash: remote.hash,
+				size: fileStat.size,
+				lastSynced: (/* @__PURE__ */ new Date()).toISOString(),
+				storageClass: remote.storageClass ?? "STANDARD"
+			};
+			return;
+		}
+		if (entry?.hash === diskHash) {
+			out.pullClean.push(path);
+			return;
+		}
+		if (entry?.hash === remote.hash) {
+			out.localAhead.push(path);
+			return;
+		}
+		out.preserve.push({
+			path,
+			diskHash,
+			size: fileStat.size
+		});
+	}
+	for (let i = 0; i < restorePaths.length; i += CLASSIFY_CONCURRENCY) await Promise.all(restorePaths.slice(i, i + CLASSIFY_CONCURRENCY).map(classifyOne));
+	return out;
+}
+function buildRecoveryReport(records, workspacePath) {
+	const lines = [
+		`# Workspace recovery report`,
+		"",
+		`A sync recovery restored this agent's cloud-saved workspace. The files`,
+		`below had local content that differed from the cloud copy. The cloud`,
+		`version now lives at the original path; the pre-recovery local version`,
+		`was preserved next to it as a \`.conflict-*\` sidecar.`,
+		"",
+		`**What to do:** open each sidecar, merge anything worth keeping into the`,
+		`live file, then delete the sidecar. Delete this report when done.`,
+		"",
+		`Paths are relative to the sync root: \`${workspacePath}\``,
+		""
+	];
+	const capped = records.filter((r) => r.tooLarge === true);
+	const kept = records.filter((r) => r.tooLarge !== true);
+	if (kept.length > 0) {
+		lines.push(`| File | Preserved copy | Local hash | Cloud hash | Size (bytes) |`);
+		lines.push(`| --- | --- | --- | --- | --- |`);
+		for (const r of kept) lines.push(`| \`${r.path}\` | \`${r.conflictPath ?? ""}\` | \`${r.localHash}\` | \`${r.remoteHash}\` | ${String(r.size)} |`);
+		lines.push("");
+	}
+	if (capped.length > 0) {
+		lines.push(`The following diverged files exceeded the sidecar size cap and were`, `replaced by the cloud version WITHOUT a preserved copy:`, "");
+		for (const r of capped) lines.push(`- \`${r.path}\` (${String(r.size)} bytes, local hash \`${r.localHash}\`)`);
+		lines.push("");
+	}
+	return lines.join("\n");
+}
+/**
+* Append the recovery nudge to the agent's HEARTBEAT.md (OpenClaw reads it
+* from the agent workspace dir on its periodic heartbeat). Returns the
+* sync-relative path when a nudge was appended, or null when a prior nudge
+* is still pending (idempotency marker present).
+*/
+async function appendRecoveryNudge(workspacePath, recoveryReportPath, preservedCount) {
+	const prefix = agentDirPrefix(workspacePath);
+	const heartbeatPath = `${prefix}HEARTBEAT.md`;
+	const absolutePath = (0, node_path.join)(workspacePath, heartbeatPath);
+	if (((0, node_fs.existsSync)(absolutePath) ? await (0, node_fs_promises.readFile)(absolutePath, "utf-8") : "").includes(RECOVERY_NUDGE_MARKER)) return null;
+	const reportForAgent = recoveryReportPath.startsWith(prefix) ? recoveryReportPath.slice(prefix.length) : recoveryReportPath;
+	const block = [
+		"",
+		RECOVERY_NUDGE_MARKER,
+		"## Workspace recovery needs your attention",
+		"",
+		`A sync recovery preserved ${String(preservedCount)} pre-recovery local file version(s)`,
+		`as \`.conflict-*\` sidecars. Read every \`RECOVERY-*.md\` report in this directory`,
+		`(latest: \`${reportForAgent}\`), merge anything worth keeping into the live files,`,
+		`then delete the sidecars, the reports, and this section (including its marker`,
+		`comment).`,
+		""
+	].join("\n");
+	await (0, node_fs_promises.mkdir)((0, node_path.dirname)(absolutePath), { recursive: true });
+	await (0, node_fs_promises.appendFile)(absolutePath, block, "utf-8");
+	return heartbeatPath;
+}
 //#endregion
 Object.defineProperty(exports, "DEFAULT_IGNORES", {
 	enumerable: true,
@@ -740,6 +1070,12 @@ Object.defineProperty(exports, "filterIgnored", {
 		return filterIgnored;
 	}
 });
+Object.defineProperty(exports, "isRecoveryArtifact", {
+	enumerable: true,
+	get: function() {
+		return isRecoveryArtifact;
+	}
+});
 Object.defineProperty(exports, "loadIgnorePatterns", {
 	enumerable: true,
 	get: function() {