@alfe.ai/openclaw-sync 0.0.6 → 0.0.7

package/dist/cli/index.cjs

@@ -0,0 +1,260 @@
+#!/usr/bin/env node
+require("../ignore.cjs");
+const require_sync_engine = require("../sync-engine.cjs");
+let node_fs_promises = require("node:fs/promises");
+let node_path = require("node:path");
+//#region src/cli/index.ts
+/**
+* AlfeSync CLI — alfesync command-line interface.
+*
+* Commands:
+*   init       - Initialize AlfeSync in a workspace
+*   push       - Push local changes to remote
+*   pull       - Pull remote changes to local
+*   status     - Show sync status and pending changes
+*   conflicts  - List conflict files
+*   history    - Show version history for a file
+*   restore    - Restore agent workspace from remote
+*/
+const program = new (require("commander")).Command();
+program.name("alfesync").description("AlfeSync — agent workspace backup and sync").version("1.0.0");
+program.command("init").description("Initialize AlfeSync in the current workspace").option("-t, --token <token>", "Alfe Connect bearer token").option("-u, --api-url <url>", "AlfeSync API URL", "https://api.alfe.ai").option("-a, --agent-id <id>", "Agent ID for this workspace").option("-n, --display-name <name>", "Display name for the agent").action(async (opts) => {
+	const workspacePath = (0, node_path.resolve)(".");
+	if (require_sync_engine.isInitialized(workspacePath)) {
+		console.log("AlfeSync is already initialized in this workspace.");
+		const existing = await require_sync_engine.readConfig(workspacePath);
+		if (existing) {
+			console.log(`  Agent: ${existing.agentId}`);
+			console.log(`  API:   ${existing.apiUrl}`);
+		}
+		return;
+	}
+	const token = opts.token ?? process.env.ALFESYNC_TOKEN;
+	const apiUrl = opts.apiUrl ?? process.env.ALFESYNC_API_URL ?? "https://api.alfe.ai";
+	const agentId = opts.agentId ?? process.env.ALFESYNC_AGENT_ID;
+	if (!token) {
+		console.error("Error: --token is required (or set ALFESYNC_TOKEN env var)");
+		process.exit(1);
+	}
+	if (!agentId) {
+		console.error("Error: --agent-id is required (or set ALFESYNC_AGENT_ID env var)");
+		process.exit(1);
+	}
+	console.log("Registering agent with AlfeSync...");
+	const client = require_sync_engine.createApiClient({
+		apiUrl,
+		token,
+		agentId
+	});
+	try {
+		const orgId = (await client.registerAgent(opts.displayName ?? agentId)).agent.orgId;
+		await require_sync_engine.writeConfig({
+			agentId,
+			orgId,
+			token,
+			workspacePath,
+			apiUrl
+		});
+		console.log("✓ AlfeSync initialized!");
+		console.log(`  Agent:     ${agentId}`);
+		console.log(`  Org:       ${orgId}`);
+		console.log(`  API:       ${apiUrl}`);
+		console.log(`  Workspace: ${workspacePath}`);
+		console.log("");
+		console.log("Run 'alfesync push' to sync your workspace.");
+	} catch (err) {
+		console.error("Failed to register agent:", err instanceof Error ? err.message : String(err));
+		process.exit(1);
+	}
+});
+program.command("push").description("Push local changes to remote").option("-q, --quiet", "Suppress output").option("-f, --filter <prefix>", "Only push files matching this prefix").action(async (opts) => {
+	const workspacePath = (0, node_path.resolve)(".");
+	try {
+		await (await require_sync_engine.createSyncEngine(workspacePath)).push(void 0, {
+			quiet: opts.quiet,
+			filter: opts.filter
+		});
+	} catch (err) {
+		console.error(err instanceof Error ? err.message : String(err));
+		process.exit(1);
+	}
+});
+program.command("pull").description("Pull remote changes to local").option("-q, --quiet", "Suppress output").action(async (opts) => {
+	const workspacePath = (0, node_path.resolve)(".");
+	try {
+		await (await require_sync_engine.createSyncEngine(workspacePath)).pull({ quiet: opts.quiet });
+	} catch (err) {
+		console.error(err instanceof Error ? err.message : String(err));
+		process.exit(1);
+	}
+});
+program.command("status").description("Show sync status and pending changes").action(async () => {
+	const workspacePath = (0, node_path.resolve)(".");
+	try {
+		const config = await require_sync_engine.readConfig(workspacePath);
+		if (!config) {
+			console.log("AlfeSync not initialized. Run: alfesync init");
+			return;
+		}
+		const client = require_sync_engine.createApiClient({
+			apiUrl: config.apiUrl,
+			token: config.token,
+			agentId: config.agentId
+		});
+		const [localManifest, remoteManifest, stats] = await Promise.all([
+			require_sync_engine.readManifest(workspacePath),
+			client.getManifest(),
+			client.getStats()
+		]);
+		const diff = require_sync_engine.diffManifests(localManifest, remoteManifest);
+		console.log("AlfeSync Status");
+		console.log("═══════════════");
+		console.log(`Agent:          ${config.agentId}`);
+		console.log(`Workspace:      ${workspacePath}`);
+		console.log(`API:            ${config.apiUrl}`);
+		console.log("");
+		console.log("Storage:");
+		console.log(`  Standard:     ${formatBytes(stats.standardBytes)}`);
+		console.log(`  Glacier IR:   ${formatBytes(stats.glacierBytes)}`);
+		console.log(`  Total files:  ${String(stats.fileCount)}`);
+		console.log(`  Last sync:    ${stats.lastSyncAt ?? "never"}`);
+		console.log("");
+		console.log("Pending Changes:");
+		console.log(`  To push:      ${String(diff.toPush.length)}`);
+		console.log(`  To pull:      ${String(diff.toPull.length)}`);
+		console.log(`  Conflicts:    ${String(diff.conflicts.length)}`);
+		if (diff.toPush.length > 0) {
+			console.log("");
+			console.log("Files to push:");
+			for (const p of diff.toPush.slice(0, 20)) console.log(`  ↑ ${p}`);
+			if (diff.toPush.length > 20) console.log(`  ... and ${String(diff.toPush.length - 20)} more`);
+		}
+		if (diff.toPull.length > 0) {
+			console.log("");
+			console.log("Files to pull:");
+			for (const p of diff.toPull.slice(0, 20)) console.log(`  ↓ ${p}`);
+			if (diff.toPull.length > 20) console.log(`  ... and ${String(diff.toPull.length - 20)} more`);
+		}
+		if (diff.conflicts.length > 0) {
+			console.log("");
+			console.log("Conflicts:");
+			for (const p of diff.conflicts) console.log(`  ⚡ ${p}`);
+		}
+	} catch (err) {
+		console.error(err instanceof Error ? err.message : String(err));
+		process.exit(1);
+	}
+});
+program.command("conflicts").description("List conflict files in the workspace").action(async () => {
+	const workspacePath = (0, node_path.resolve)(".");
+	try {
+		const conflicts = await findConflictFiles(workspacePath);
+		if (conflicts.length === 0) {
+			console.log("No conflict files found.");
+			return;
+		}
+		console.log(`Found ${String(conflicts.length)} conflict file(s):`);
+		for (const f of conflicts) console.log(`  ⚡ ${f}`);
+	} catch (err) {
+		console.error(err instanceof Error ? err.message : String(err));
+		process.exit(1);
+	}
+});
+program.command("history <file>").description("Show version history for a file").action(async (file) => {
+	const workspacePath = (0, node_path.resolve)(".");
+	try {
+		const config = await require_sync_engine.readConfig(workspacePath);
+		if (!config) {
+			console.log("AlfeSync not initialized. Run: alfesync init");
+			return;
+		}
+		const versions = await require_sync_engine.createApiClient({
+			apiUrl: config.apiUrl,
+			token: config.token,
+			agentId: config.agentId
+		}).getFileHistory(file);
+		if (versions.length === 0) {
+			console.log(`No history found for: ${file}`);
+			return;
+		}
+		console.log(`Version history for: ${file}`);
+		console.log("─".repeat(60));
+		for (const v of versions) {
+			const marker = v.isLatest ? " (latest)" : "";
+			console.log(`  ${v.lastModified}  ${formatBytes(v.size)}  ${v.versionId.slice(0, 12)}${marker}`);
+		}
+	} catch (err) {
+		console.error(err instanceof Error ? err.message : String(err));
+		process.exit(1);
+	}
+});
+program.command("restore").description("Restore agent workspace from remote backup").option("-m, --mode <mode>", "Restore mode: full, active, memory", "full").option("-q, --quiet", "Suppress output").action(async (opts) => {
+	const workspacePath = (0, node_path.resolve)(".");
+	try {
+		const config = await require_sync_engine.readConfig(workspacePath);
+		if (!config) {
+			console.log("AlfeSync not initialized. Run: alfesync init");
+			return;
+		}
+		const mode = opts.mode;
+		if (![
+			"full",
+			"active",
+			"memory"
+		].includes(mode)) {
+			console.error("Error: mode must be full, active, or memory");
+			process.exit(1);
+		}
+		const client = require_sync_engine.createApiClient({
+			apiUrl: config.apiUrl,
+			token: config.token,
+			agentId: config.agentId
+		});
+		if (!opts.quiet) console.log(`Restoring workspace (mode: ${mode})...`);
+		const bundle = await client.reconstruct(mode);
+		if (!opts.quiet) console.log(`Downloading ${String(bundle.fileCount)} files (${formatBytes(bundle.totalSize)})...`);
+		const { writeFile, mkdir } = await import("node:fs/promises");
+		const { dirname } = await import("node:path");
+		let downloaded = 0;
+		let errors = 0;
+		for (const file of bundle.files) try {
+			const response = await fetch(file.url);
+			if (!response.ok) throw new Error(`HTTP ${String(response.status)}`);
+			const buffer = Buffer.from(await response.arrayBuffer());
+			const absolutePath = (0, node_path.join)(workspacePath, file.path);
+			await mkdir(dirname(absolutePath), { recursive: true });
+			await writeFile(absolutePath, buffer);
+			downloaded++;
+			if (!opts.quiet) console.log(`  ↓ ${file.path} (${formatBytes(file.size)})`);
+		} catch (err) {
+			errors++;
+			if (!opts.quiet) console.error(`  ✗ ${file.path}: ${err instanceof Error ? err.message : String(err)}`);
+		}
+		if (!opts.quiet) console.log(`\nRestore complete: ${String(downloaded)} files downloaded, ${String(errors)} errors.`);
+	} catch (err) {
+		console.error(err instanceof Error ? err.message : String(err));
+		process.exit(1);
+	}
+});
+async function findConflictFiles(dir, base) {
+	const results = [];
+	const entries = await (0, node_fs_promises.readdir)(dir, { withFileTypes: true });
+	for (const entry of entries) {
+		if (entry.name === "node_modules" || entry.name === ".git" || entry.name === ".alfesync") continue;
+		const fullPath = (0, node_path.join)(dir, entry.name);
+		const relativePath = base ? (0, node_path.join)(base, entry.name) : entry.name;
+		if (entry.isDirectory()) {
+			const sub = await findConflictFiles(fullPath, relativePath);
+			results.push(...sub);
+		} else if (entry.name.includes(".conflict-")) results.push(relativePath);
+	}
+	return results;
+}
+function formatBytes(bytes) {
+	if (bytes < 1024) return `${String(bytes)} B`;
+	if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+	if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+	return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)} GB`;
+}
+program.parse();
+//#endregion

package/dist/cli/index.d.cts

@@ -0,0 +1 @@
+export {};

package/dist/ignore.cjs

@@ -0,0 +1,120 @@
+//#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 __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+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 micromatch = require("micromatch");
+micromatch = __toESM(micromatch);
+//#region src/ignore.ts
+/**
+* AlfeSync ignore — parse `.alfesyncignore` (gitignore-style glob matching).
+*
+* Uses micromatch for glob pattern matching, compatible with .gitignore syntax.
+*/
+var ignore_exports = /* @__PURE__ */ __exportAll({
+	filterIgnored: () => filterIgnored,
+	loadIgnorePatterns: () => loadIgnorePatterns,
+	shouldIgnore: () => shouldIgnore
+});
+/** 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);
+		}
+	} 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
+Object.defineProperty(exports, "__toESM", {
+	enumerable: true,
+	get: function() {
+		return __toESM;
+	}
+});
+Object.defineProperty(exports, "filterIgnored", {
+	enumerable: true,
+	get: function() {
+		return filterIgnored;
+	}
+});
+Object.defineProperty(exports, "ignore_exports", {
+	enumerable: true,
+	get: function() {
+		return ignore_exports;
+	}
+});
+Object.defineProperty(exports, "loadIgnorePatterns", {
+	enumerable: true,
+	get: function() {
+		return loadIgnorePatterns;
+	}
+});
+Object.defineProperty(exports, "shouldIgnore", {
+	enumerable: true,
+	get: function() {
+		return shouldIgnore;
+	}
+});