remoteclaw 0.1.0-next.2abd2fa → 0.1.0-next.2e9a6cd

package/dist/import-DIjlFm_Y.js

@@ -0,0 +1,493 @@
+import { Gt as resolveNewStateDir, _ as defaultRuntime, ot as shortenHomePath } from "./entry.js";
+import { t as RemoteClawSchema } from "./zod-schema-B9RGngMW.js";
+import { t as createClackPrompter } from "./clack-prompter-D6HhVlZW.js";
+import path from "node:path";
+import fs from "node:fs";
+import fsp from "node:fs/promises";
+
+//#region src/commands/import.ts
+/**
+* Config key prefixes that need rewriting during import.
+* The import rewrites env var references from the OpenClaw namespace
+* to the RemoteClaw namespace.
+*/
+const ENV_VAR_PREFIX_OLD = "OPENCLAW_";
+const ENV_VAR_PREFIX_NEW = "REMOTECLAW_";
+/**
+* OpenClaw config filename that gets renamed during import.
+*/
+const OPENCLAW_CONFIG_FILENAME = "openclaw.json";
+const REMOTECLAW_CONFIG_FILENAME = "remoteclaw.json";
+/**
+* Default agent id used by OpenClaw when no explicit id is set.
+*/
+const DEFAULT_AGENT_ID = "main";
+/**
+* Default workspace path for the default agent.
+*/
+const DEFAULT_WORKSPACE = "~/.remoteclaw/workspace";
+/**
+* Keys whose presence indicates the config has substantive content
+* (i.e. it's a real config, not an empty/skeleton file).
+*/
+const SUBSTANTIVE_CONFIG_KEYS = new Set([
+	"channels",
+	"plugins",
+	"gateway",
+	"bindings",
+	"broadcast",
+	"cron",
+	"hooks",
+	"discovery"
+]);
+/**
+* Auth profile filenames used for discovery during import.
+*/
+const AUTH_PROFILES_FILENAME = "auth-profiles.json";
+const LEGACY_AUTH_FILENAME = "auth.json";
+/**
+* Runtime-to-provider mapping for auto-detecting auth profiles.
+* Profile IDs use `{provider}:{name}` format; the provider prefix is matched
+* against these lists.
+*/
+const RUNTIME_AUTH_PROVIDERS = {
+	claude: ["anthropic", "claude"],
+	gemini: ["google"],
+	codex: [
+		"codex",
+		"openai",
+		"openai-codex"
+	],
+	opencode: [
+		"openai",
+		"anthropic",
+		"opencode"
+	]
+};
+/**
+* Transform config content by replacing OPENCLAW_* env var references
+* with REMOTECLAW_* equivalents.
+*
+* Handles both `${OPENCLAW_*}` template references and bare `OPENCLAW_*` string values.
+*/
+function transformConfigContent(content) {
+	const renames = [];
+	let transformed = content.replace(/\$\{(OPENCLAW_\w+)\}/g, (_match, varName) => {
+		const newVarName = varName.replace(ENV_VAR_PREFIX_OLD, ENV_VAR_PREFIX_NEW);
+		renames.push(`\${${varName}} -> \${${newVarName}}`);
+		return `\${${newVarName}}`;
+	});
+	transformed = transformed.replace(/("(?:[^"\\]|\\.)*")/g, (match) => {
+		if (match.includes(ENV_VAR_PREFIX_OLD)) return match.replace(new RegExp(`${ENV_VAR_PREFIX_OLD}(\\w+)`, "g"), (_m, suffix) => {
+			const oldName = `${ENV_VAR_PREFIX_OLD}${suffix}`;
+			const newName = `${ENV_VAR_PREFIX_NEW}${suffix}`;
+			renames.push(`${oldName} -> ${newName}`);
+			return newName;
+		});
+		return match;
+	});
+	transformed = transformed.replace(/("(?:[^"\\]|\\.)*")/g, (match) => {
+		if (match.includes("/.openclaw/") || match.includes("\\.openclaw\\")) return match.replace(/\/\.openclaw\//g, "/.remoteclaw/").replace(/\\\.openclaw\\/g, "\\.remoteclaw\\");
+		return match;
+	});
+	return {
+		content: transformed,
+		renames: [...new Set(renames)]
+	};
+}
+/**
+* Build a recursive key-tree from a Zod schema by walking `.shape` properties.
+* Unwraps optional/nullable/default wrappers via `.unwrap()` to reach the
+* underlying object shape. Returns `null` for non-object schemas (leaves).
+*/
+function buildKeyTree(schema) {
+	let current = schema;
+	while (current && typeof current === "object" && "unwrap" in current && typeof current.unwrap === "function") current = current.unwrap();
+	if (!current || typeof current !== "object" || !("shape" in current) || !current.shape || typeof current.shape !== "object") return null;
+	const def = "_zod" in current && current._zod && typeof current._zod === "object" && "def" in current._zod && current._zod.def && typeof current._zod.def === "object" ? current._zod.def : null;
+	const catchallSchema = def !== null && "catchall" in def ? def.catchall : null;
+	const hasCatchall = Boolean(catchallSchema != null && typeof catchallSchema === "object" && "_zod" in catchallSchema && catchallSchema._zod && typeof catchallSchema._zod === "object" && "def" in catchallSchema._zod && catchallSchema._zod.def && typeof catchallSchema._zod.def === "object" && "type" in catchallSchema._zod.def && catchallSchema._zod.def.type !== "never");
+	const shape = current.shape;
+	const children = /* @__PURE__ */ new Map();
+	for (const [key, fieldSchema] of Object.entries(shape)) children.set(key, buildKeyTree(fieldSchema));
+	return {
+		children,
+		catchall: hasCatchall
+	};
+}
+/** Pre-built key tree from the root config schema, computed once at module load. */
+const CONFIG_KEY_TREE = buildKeyTree(RemoteClawSchema);
+/**
+* Recursively filter an object to only keep keys present in the key tree.
+* Keys in catchall objects are always preserved.
+*/
+function filterByKeyTree(obj, node) {
+	let changed = false;
+	const result = {};
+	for (const [key, value] of Object.entries(obj)) {
+		if (!node.children.has(key)) {
+			if (node.catchall) result[key] = value;
+			else changed = true;
+			continue;
+		}
+		const childNode = node.children.get(key);
+		if (childNode && value !== null && typeof value === "object" && !Array.isArray(value)) {
+			const nested = filterByKeyTree(value, childNode);
+			result[key] = nested.result;
+			if (nested.changed) changed = true;
+		} else result[key] = value;
+	}
+	return {
+		result,
+		changed
+	};
+}
+/**
+* Strip unrecognized keys from the entire config JSON by filtering against
+* the current RemoteClawSchema shape tree.
+*
+* OpenClaw configs may contain keys that RemoteClaw's schema no longer accepts.
+* Instead of maintaining a denylist of dead keys, this function keeps only keys
+* the current schema recognizes — any key we don't know about is dropped.
+* Recurses into nested strict objects so sub-keys are filtered too.
+*/
+function stripUnrecognizedConfigKeys(jsonContent) {
+	let config;
+	try {
+		config = JSON.parse(jsonContent);
+	} catch {
+		return jsonContent;
+	}
+	if (typeof config !== "object" || config === null || Array.isArray(config)) return jsonContent;
+	const { result, changed } = filterByKeyTree(config, CONFIG_KEY_TREE);
+	if (!changed) return jsonContent;
+	const indent = jsonContent.match(/^(\s+)"/m)?.[1] ?? "  ";
+	return JSON.stringify(result, null, indent) + "\n";
+}
+/**
+* Remove the `wizard` section from imported config.
+*
+* OpenClaw configs carry wizard state (`wizard.lastRunVersion`,
+* `wizard.lastRunCommand`, etc.) that reflects OpenClaw's wizard history.
+* This is misleading after import — RemoteClaw's wizard has never run.
+* Clearing the section ensures the user gets a fresh wizard experience.
+*/
+function clearWizardSection(jsonContent) {
+	let config;
+	try {
+		config = JSON.parse(jsonContent);
+	} catch {
+		return jsonContent;
+	}
+	if (typeof config !== "object" || config === null || Array.isArray(config)) return jsonContent;
+	if (!("wizard" in config)) return jsonContent;
+	delete config.wizard;
+	const indent = jsonContent.match(/^(\s+)"/m)?.[1] ?? "  ";
+	return JSON.stringify(config, null, indent) + "\n";
+}
+/**
+* Materialize implicit OpenClaw workspace defaults into the main config JSON.
+*
+* OpenClaw had a three-tier workspace resolution chain that was removed in
+* #278 and #298. After import, configs that relied on those implicit defaults
+* fail validation. This function makes those defaults explicit:
+*
+* 1. For each agent in agents.list[] without workspace:
+*    - Use agents.defaults.workspace if set
+*    - Else default agent → ~/.remoteclaw/workspace
+*    - Else non-default → ~/.remoteclaw/workspace-{id}
+* 2. If agents.list is empty/missing but config has substantive content,
+*    create a default agent entry.
+* 3. Remove agents.defaults.workspace after consuming it.
+*/
+function materializeWorkspaceDefaults(jsonContent) {
+	let config;
+	try {
+		config = JSON.parse(jsonContent);
+	} catch {
+		return jsonContent;
+	}
+	if (typeof config !== "object" || config === null || Array.isArray(config)) return jsonContent;
+	const agents = config.agents;
+	const agentsList = agents?.list ?? [];
+	const defaultsWorkspace = typeof (agents?.defaults)?.workspace === "string" ? agents.defaults.workspace : void 0;
+	const hasSubstantiveContent = Object.keys(config).some((key) => SUBSTANTIVE_CONFIG_KEYS.has(key));
+	let mutated = false;
+	if (agentsList.length === 0 && hasSubstantiveContent) {
+		const newAgents = agents ?? {};
+		newAgents.list = [{
+			id: DEFAULT_AGENT_ID,
+			workspace: DEFAULT_WORKSPACE
+		}];
+		config.agents = newAgents;
+		mutated = true;
+	} else for (const entry of agentsList) {
+		if (typeof entry.workspace === "string" && entry.workspace.trim()) continue;
+		if (defaultsWorkspace) entry.workspace = defaultsWorkspace;
+		else {
+			const id = typeof entry.id === "string" ? entry.id.trim() : "";
+			entry.workspace = entry.default === true || id === DEFAULT_AGENT_ID || agentsList.length === 1 ? DEFAULT_WORKSPACE : `~/.remoteclaw/workspace-${id || DEFAULT_AGENT_ID}`;
+		}
+		mutated = true;
+	}
+	if (defaultsWorkspace && config.agents) {
+		const defaults = config.agents.defaults;
+		if (defaults) {
+			delete defaults.workspace;
+			if (Object.keys(defaults).length === 0) delete config.agents.defaults;
+			mutated = true;
+		}
+	}
+	if (!mutated) return jsonContent;
+	const indent = jsonContent.match(/^(\s+)"/m)?.[1] ?? "  ";
+	return JSON.stringify(config, null, indent) + "\n";
+}
+/**
+* Discover auth profile IDs from auth store files in the source directory.
+*
+* Walks the directory tree looking for `auth-profiles.json` (v1 format)
+* and legacy `auth.json` files. Returns deduplicated profile IDs.
+*/
+function discoverSourceAuthProfileIds(sourceDir) {
+	const profileIds = [];
+	const walk = (dir) => {
+		let entries;
+		try {
+			entries = fs.readdirSync(dir, { withFileTypes: true });
+		} catch {
+			return;
+		}
+		for (const entry of entries) {
+			const fullPath = path.join(dir, entry.name);
+			if (entry.isDirectory()) walk(fullPath);
+			else if (entry.isFile()) {
+				if (entry.name === AUTH_PROFILES_FILENAME) collectModernStore(fullPath, profileIds);
+				else if (entry.name === LEGACY_AUTH_FILENAME) collectLegacyStore(fullPath, profileIds);
+			}
+		}
+	};
+	walk(sourceDir);
+	return [...new Set(profileIds)];
+}
+function collectModernStore(filePath, out) {
+	try {
+		const raw = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+		if (raw?.profiles && typeof raw.profiles === "object") out.push(...Object.keys(raw.profiles));
+	} catch {}
+}
+function collectLegacyStore(filePath, out) {
+	try {
+		const raw = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+		if (typeof raw !== "object" || raw === null || "profiles" in raw) return;
+		for (const [key, value] of Object.entries(raw)) if (value && typeof value === "object" && value.type === "api_key") out.push(`${key}:default`);
+	} catch {}
+}
+/**
+* Materialize the `agents.defaults.auth` field from discovered auth profiles.
+*
+* OpenClaw configs don't have the `auth` field. After import, auth profiles
+* exist on disk but nothing in the config points to them. This function
+* detects the configured runtime and sets `agents.defaults.auth` to the
+* first profile whose provider matches the runtime.
+*/
+function materializeAuthDefaults(jsonContent, discoveredProfileIds) {
+	if (discoveredProfileIds.length === 0) return jsonContent;
+	let config;
+	try {
+		config = JSON.parse(jsonContent);
+	} catch {
+		return jsonContent;
+	}
+	if (typeof config !== "object" || config === null || Array.isArray(config)) return jsonContent;
+	const defaults = config.agents?.defaults;
+	if (defaults?.auth !== void 0) return jsonContent;
+	const runtime = typeof defaults?.runtime === "string" ? defaults.runtime : void 0;
+	if (!runtime) return jsonContent;
+	const providers = RUNTIME_AUTH_PROVIDERS[runtime];
+	if (!providers) return jsonContent;
+	const matchingProfileId = discoveredProfileIds.find((id) => {
+		const colonIdx = id.indexOf(":");
+		const provider = (colonIdx > 0 ? id.slice(0, colonIdx) : id).toLowerCase();
+		return providers.includes(provider);
+	});
+	if (!matchingProfileId) return jsonContent;
+	if (!config.agents) config.agents = {};
+	const agentsObj = config.agents;
+	if (!agentsObj.defaults) agentsObj.defaults = {};
+	agentsObj.defaults.auth = matchingProfileId;
+	const indent = jsonContent.match(/^(\s+)"/m)?.[1] ?? "  ";
+	return JSON.stringify(config, null, indent) + "\n";
+}
+/**
+* Determine the target filename for a source file.
+* Renames openclaw.json -> remoteclaw.json at any directory level.
+*/
+function resolveTargetFilename(filename) {
+	if (filename === OPENCLAW_CONFIG_FILENAME) return REMOTECLAW_CONFIG_FILENAME;
+	return filename;
+}
+/**
+* Top-level entries in the OpenClaw state directory that should be imported.
+*
+* Only entries in this set (plus the `workspace-*` pattern) are copied from
+* the source root. Everything else — generated caches (`completions/`),
+* runtime state (`delivery-queue/`, `sandbox/`, `restart-sentinel.json`),
+* device-specific data (`identity/`), and removed subsystems (`packs/`) —
+* is intentionally skipped.
+*
+* Sub-directories within importable entries are copied recursively without
+* further filtering.
+*/
+const IMPORTABLE_ROOT_ENTRIES = new Set([
+	OPENCLAW_CONFIG_FILENAME,
+	REMOTECLAW_CONFIG_FILENAME,
+	".env",
+	"agents",
+	"agent",
+	"sessions",
+	"credentials",
+	"extensions",
+	"hooks",
+	"includes",
+	"telegram",
+	"media",
+	"workspace"
+]);
+/**
+* Check whether a root-level entry name should be imported.
+* Matches the static allowlist plus `workspace-{agentId}` directories.
+*/
+function isImportableRootEntry(name) {
+	if (IMPORTABLE_ROOT_ENTRIES.has(name)) return true;
+	if (name.startsWith("workspace-") && name.length > 10) return true;
+	return false;
+}
+/**
+* Check whether a file is a JSON/JSON5 config file that should be transformed.
+*/
+function isConfigFile(filename) {
+	return filename.endsWith(".json") || filename.endsWith(".json5");
+}
+/**
+* Recursively copy a directory, transforming config files along the way.
+*
+* When `filterRoot` is true (used for the top-level source directory),
+* only entries matching the importable allowlist are processed.
+* Sub-directories are always copied in full without filtering.
+*/
+async function copyDirectory(params) {
+	const { sourceDir, targetDir, dryRun, filterRoot, result } = params;
+	const entries = await fsp.readdir(sourceDir, { withFileTypes: true });
+	if (!dryRun) await fsp.mkdir(targetDir, { recursive: true });
+	for (const entry of entries) {
+		if (filterRoot && !isImportableRootEntry(entry.name)) {
+			result.skippedEntries.push(entry.name);
+			continue;
+		}
+		const sourcePath = path.join(sourceDir, entry.name);
+		const targetFilename = resolveTargetFilename(entry.name);
+		const targetPath = path.join(targetDir, targetFilename);
+		if (entry.isDirectory()) await copyDirectory({
+			sourceDir: sourcePath,
+			targetDir: targetPath,
+			dryRun,
+			filterRoot: false,
+			result,
+			discoveredAuthProfileIds: params.discoveredAuthProfileIds
+		});
+		else if (entry.isFile()) if (isConfigFile(entry.name)) {
+			const { content: transformed, renames } = transformConfigContent(await fsp.readFile(sourcePath, "utf-8"));
+			const final = entry.name === OPENCLAW_CONFIG_FILENAME ? materializeAuthDefaults(materializeWorkspaceDefaults(clearWizardSection(stripUnrecognizedConfigKeys(transformed))), params.discoveredAuthProfileIds) : transformed;
+			if (renames.length > 0 || final !== transformed) {
+				result.transformedFiles.push(targetPath);
+				result.envVarRenames.push(...renames);
+			}
+			if (!dryRun) await fsp.writeFile(targetPath, final, "utf-8");
+			result.copiedFiles.push(targetPath);
+		} else {
+			if (!dryRun) await fsp.copyFile(sourcePath, targetPath);
+			result.copiedFiles.push(targetPath);
+		}
+	}
+}
+/**
+* Execute the import migration from an OpenClaw installation to RemoteClaw.
+*/
+async function importCommand(opts, runtime = defaultRuntime) {
+	const sourcePath = path.resolve(opts.sourcePath.replace(/^~/, process.env.HOME ?? "~"));
+	const targetDir = resolveNewStateDir();
+	if (!fs.existsSync(sourcePath)) {
+		runtime.error(`Source path does not exist: ${shortenHomePath(sourcePath)}`);
+		runtime.exit(1);
+		return null;
+	}
+	if (!(await fsp.stat(sourcePath)).isDirectory()) {
+		runtime.error(`Source path is not a directory: ${shortenHomePath(sourcePath)}`);
+		runtime.exit(1);
+		return null;
+	}
+	if (fs.existsSync(targetDir) && !opts.yes && !opts.dryRun) {
+		if (opts.nonInteractive) {
+			runtime.error(`Target directory already exists: ${shortenHomePath(targetDir)}\nUse --yes to overwrite.`);
+			runtime.exit(1);
+			return null;
+		}
+		if (!await createClackPrompter().confirm({
+			message: `Target directory ${shortenHomePath(targetDir)} already exists. Merge imported files into it?`,
+			initialValue: false
+		})) {
+			runtime.log("Import cancelled.");
+			runtime.exit(0);
+			return null;
+		}
+	}
+	const result = {
+		copiedFiles: [],
+		transformedFiles: [],
+		envVarRenames: [],
+		skippedEntries: [],
+		targetDir
+	};
+	if (opts.dryRun) runtime.log("Dry run — no files will be written.\n");
+	runtime.log(`Importing from ${shortenHomePath(sourcePath)} to ${shortenHomePath(targetDir)}...\n`);
+	const discoveredAuthProfileIds = discoverSourceAuthProfileIds(sourcePath);
+	await copyDirectory({
+		sourceDir: sourcePath,
+		targetDir,
+		dryRun: Boolean(opts.dryRun),
+		filterRoot: true,
+		result,
+		discoveredAuthProfileIds
+	});
+	result.envVarRenames = [...new Set(result.envVarRenames)];
+	runtime.log(`Copied ${result.copiedFiles.length} file(s).`);
+	if (result.transformedFiles.length > 0) {
+		runtime.log(`Transformed ${result.transformedFiles.length} config file(s):`);
+		for (const file of result.transformedFiles) runtime.log(`  ${shortenHomePath(file)}`);
+	}
+	if (result.envVarRenames.length > 0) {
+		runtime.log(`\nEnv var renames:`);
+		for (const rename of result.envVarRenames) runtime.log(`  ${rename}`);
+	}
+	if (result.skippedEntries.length > 0) {
+		runtime.log(`\nSkipped ${result.skippedEntries.length} non-importable entry(s):`);
+		for (const entry of result.skippedEntries) runtime.log(`  ${entry}`);
+	}
+	if (opts.dryRun) runtime.log("\nDry run complete — no changes were made.");
+	else runtime.log("\nImport complete.");
+	return result;
+}
+/**
+* Detect whether an OpenClaw installation exists at the default location.
+* Used by the onboarding wizard to offer migration.
+*/
+function detectOpenClawInstallation(homedir = process.env.HOME ?? "") {
+	const openclawDir = path.join(homedir, ".openclaw");
+	if (fs.existsSync(openclawDir)) try {
+		if (fs.statSync(openclawDir).isDirectory()) return openclawDir;
+	} catch {}
+	return null;
+}
+
+//#endregion
+export { importCommand as n, detectOpenClawInstallation as t };