remoteclaw 0.1.0-next.da482d8 → 0.1.0-next.db8a792

package/dist/import-cBp4f62k.js

@@ -0,0 +1,606 @@
+import { p as resolveNewStateDir } from "./paths-BTaH3rLn.js";
+import { b as shortenHomePath } from "./utils-C5daYcFn.js";
+import { i as defaultRuntime } from "./ansi-DtaiOnt1.js";
+import { t as VERSION } from "./version-CVMnqdzu.js";
+import { t as RemoteClawSchema } from "./zod-schema-CCUbW_Si.js";
+import { t as createClackPrompter } from "./clack-prompter-CFNKgQXx.js";
+import fs from "node:fs";
+import path from "node:path";
+import fs$1 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";
+}
+/**
+* Strip the `$schema` field from config JSON.
+*
+* OpenClaw configs may contain `"$schema": "https://openclaw.org/..."` pointing
+* to an OpenClaw schema URL. Rather than rewriting to a RemoteClaw URL (which
+* may have a different format), we strip the field entirely — RemoteClaw will
+* write its own `$schema` on the next config save if needed.
+*/
+function stripSchemaField(jsonContent) {
+	let config;
+	try {
+		config = JSON.parse(jsonContent);
+	} catch {
+		return jsonContent;
+	}
+	if (typeof config !== "object" || config === null || Array.isArray(config)) return jsonContent;
+	if (!("$schema" in config)) return jsonContent;
+	delete config.$schema;
+	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 full auth profile credentials 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 all discovered profiles with
+* their credentials and source paths for conflict detection.
+*/
+function discoverSourceAuthProfiles(sourceDir) {
+	const profiles = [];
+	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, profiles);
+				else if (entry.name === LEGACY_AUTH_FILENAME) collectLegacyStore(fullPath, profiles);
+			}
+		}
+	};
+	walk(sourceDir);
+	return profiles;
+}
+function collectModernStore(filePath, out) {
+	try {
+		const raw = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+		if (raw?.profiles && typeof raw.profiles === "object") {
+			for (const [id, credential] of Object.entries(raw.profiles)) if (credential && typeof credential === "object") out.push({
+				id,
+				credential,
+				sourceFile: filePath
+			});
+		}
+	} 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" || value.type === "token")) out.push({
+			id: `${key}:default`,
+			credential: value,
+			sourceFile: filePath
+		});
+	} 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";
+}
+/**
+* Consolidate discovered auth profiles into a single global auth store.
+*
+* Merges all profiles into one store, writing it to `targetDir/auth-profiles.json`.
+* When the same profile ID appears in multiple source files with different keys,
+* a warning is emitted and the first occurrence wins.
+*/
+async function consolidateAuthProfiles(params) {
+	const { profiles, targetDir, sourceDir, dryRun, result, runtime } = params;
+	if (profiles.length === 0) return;
+	const merged = {};
+	for (const { id, credential, sourceFile } of profiles) {
+		if (id in merged) {
+			if (merged[id].key !== credential.key) {
+				const warning = `Auth profile "${id}" found in ${path.relative(sourceDir, sourceFile)} conflicts with earlier occurrence — keeping first`;
+				result.authProfileConflicts.push(warning);
+				runtime.log(`Warning: ${warning}`);
+			}
+			continue;
+		}
+		merged[id] = credential;
+		result.consolidatedAuthProfiles.push(id);
+	}
+	if (!dryRun) {
+		const store = {
+			version: 1,
+			profiles: merged
+		};
+		const storePath = path.join(targetDir, AUTH_PROFILES_FILENAME);
+		await fs$1.mkdir(targetDir, { recursive: true });
+		await fs$1.writeFile(storePath, JSON.stringify(store, null, 2) + "\n", "utf-8");
+	}
+}
+/**
+* Stamp `meta.lastTouchedVersion` and `meta.lastTouchedAt` on imported config JSON.
+*
+* OpenClaw configs carry the OpenClaw version in `meta.lastTouchedVersion`.
+* After import, RemoteClaw is the last tool that wrote the config, so the
+* version must be updated to prevent `warnIfConfigFromFuture()` from firing
+* a spurious "newer RemoteClaw" warning.
+*/
+function stampImportedConfigVersion(jsonContent) {
+	let config;
+	try {
+		config = JSON.parse(jsonContent);
+	} catch {
+		return jsonContent;
+	}
+	if (typeof config !== "object" || config === null || Array.isArray(config)) return jsonContent;
+	const meta = config.meta ?? {};
+	meta.lastTouchedVersion = VERSION;
+	meta.lastTouchedAt = (/* @__PURE__ */ new Date()).toISOString();
+	config.meta = meta;
+	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`),
+* identity 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",
+	"cron",
+	"devices",
+	"canvas"
+]);
+/**
+* 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 fs$1.readdir(sourceDir, { withFileTypes: true });
+	if (!dryRun) await fs$1.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 (entry.name === AUTH_PROFILES_FILENAME) continue;
+			if (isConfigFile(entry.name)) {
+				const { content: transformed, renames } = transformConfigContent(await fs$1.readFile(sourcePath, "utf-8"));
+				const final = entry.name === OPENCLAW_CONFIG_FILENAME ? stampImportedConfigVersion(materializeAuthDefaults(materializeWorkspaceDefaults(clearWizardSection(stripUnrecognizedConfigKeys(stripSchemaField(transformed)))), params.discoveredAuthProfileIds)) : transformed;
+				if (renames.length > 0 || final !== transformed) {
+					result.transformedFiles.push(targetPath);
+					result.envVarRenames.push(...renames);
+				}
+				if (!dryRun) await fs$1.writeFile(targetPath, final, "utf-8");
+				result.copiedFiles.push(targetPath);
+			} else {
+				if (!dryRun) await fs$1.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 fs$1.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,
+		consolidatedAuthProfiles: [],
+		authProfileConflicts: []
+	};
+	if (opts.dryRun) runtime.log("Dry run — no files will be written.\n");
+	runtime.log(`Importing from ${shortenHomePath(sourcePath)} to ${shortenHomePath(targetDir)}...\n`);
+	const discoveredAuthProfiles = discoverSourceAuthProfiles(sourcePath);
+	const discoveredAuthProfileIds = [...new Set(discoveredAuthProfiles.map((p) => p.id))];
+	await copyDirectory({
+		sourceDir: sourcePath,
+		targetDir,
+		dryRun: Boolean(opts.dryRun),
+		filterRoot: true,
+		result,
+		discoveredAuthProfileIds
+	});
+	await consolidateAuthProfiles({
+		profiles: discoveredAuthProfiles,
+		targetDir,
+		sourceDir: sourcePath,
+		dryRun: Boolean(opts.dryRun),
+		result,
+		runtime
+	});
+	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.consolidatedAuthProfiles.length > 0) {
+		runtime.log(`\nConsolidated ${result.consolidatedAuthProfiles.length} auth profile(s) into global store:`);
+		for (const id of result.consolidatedAuthProfiles) runtime.log(`  ${id}`);
+	}
+	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 };

package/dist/inbound-context-COwswi8z.js

@@ -0,0 +1,68 @@
+import { t as __exportAll } from "./rolldown-runtime-Cbj13DAv.js";
+import { t as normalizeChatType } from "./chat-type-CE6cJOyt.js";
+import { n as resolveConversationLabel } from "./conversation-label-HuHoShPF.js";
+
+//#region src/auto-reply/reply/inbound-text.ts
+function normalizeInboundTextNewlines(input) {
+	return input.replaceAll("\r\n", "\n").replaceAll("\r", "\n");
+}
+
+//#endregion
+//#region src/auto-reply/reply/inbound-context.ts
+var inbound_context_exports = /* @__PURE__ */ __exportAll({ finalizeInboundContext: () => finalizeInboundContext });
+const DEFAULT_MEDIA_TYPE = "application/octet-stream";
+function normalizeTextField(value) {
+	if (typeof value !== "string") return;
+	return normalizeInboundTextNewlines(value);
+}
+function normalizeMediaType(value) {
+	if (typeof value !== "string") return;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : void 0;
+}
+function countMediaEntries(ctx) {
+	const pathCount = Array.isArray(ctx.MediaPaths) ? ctx.MediaPaths.length : 0;
+	const urlCount = Array.isArray(ctx.MediaUrls) ? ctx.MediaUrls.length : 0;
+	const single = ctx.MediaPath || ctx.MediaUrl ? 1 : 0;
+	return Math.max(pathCount, urlCount, single);
+}
+function finalizeInboundContext(ctx, opts = {}) {
+	const normalized = ctx;
+	normalized.Body = normalizeInboundTextNewlines(typeof normalized.Body === "string" ? normalized.Body : "");
+	normalized.RawBody = normalizeTextField(normalized.RawBody);
+	normalized.CommandBody = normalizeTextField(normalized.CommandBody);
+	normalized.Transcript = normalizeTextField(normalized.Transcript);
+	normalized.ThreadStarterBody = normalizeTextField(normalized.ThreadStarterBody);
+	normalized.ThreadHistoryBody = normalizeTextField(normalized.ThreadHistoryBody);
+	if (Array.isArray(normalized.UntrustedContext)) normalized.UntrustedContext = normalized.UntrustedContext.map((entry) => normalizeInboundTextNewlines(entry)).filter((entry) => Boolean(entry));
+	const chatType = normalizeChatType(normalized.ChatType);
+	if (chatType && (opts.forceChatType || normalized.ChatType !== chatType)) normalized.ChatType = chatType;
+	normalized.BodyForAgent = normalizeInboundTextNewlines(opts.forceBodyForAgent ? normalized.Body : normalized.BodyForAgent ?? normalized.CommandBody ?? normalized.RawBody ?? normalized.Body);
+	normalized.BodyForCommands = normalizeInboundTextNewlines(opts.forceBodyForCommands ? normalized.CommandBody ?? normalized.RawBody ?? normalized.Body : normalized.BodyForCommands ?? normalized.CommandBody ?? normalized.RawBody ?? normalized.Body);
+	const explicitLabel = normalized.ConversationLabel?.trim();
+	if (opts.forceConversationLabel || !explicitLabel) {
+		const resolved = resolveConversationLabel(normalized)?.trim();
+		if (resolved) normalized.ConversationLabel = resolved;
+	} else normalized.ConversationLabel = explicitLabel;
+	normalized.CommandAuthorized = normalized.CommandAuthorized === true;
+	const mediaCount = countMediaEntries(normalized);
+	if (mediaCount > 0) {
+		const mediaType = normalizeMediaType(normalized.MediaType);
+		const normalizedMediaTypes = (Array.isArray(normalized.MediaTypes) ? normalized.MediaTypes : void 0)?.map((entry) => normalizeMediaType(entry));
+		let mediaTypesFinal;
+		if (normalizedMediaTypes && normalizedMediaTypes.length > 0) {
+			const filled = normalizedMediaTypes.slice();
+			while (filled.length < mediaCount) filled.push(void 0);
+			mediaTypesFinal = filled.map((entry) => entry ?? DEFAULT_MEDIA_TYPE);
+		} else if (mediaType) {
+			mediaTypesFinal = [mediaType];
+			while (mediaTypesFinal.length < mediaCount) mediaTypesFinal.push(DEFAULT_MEDIA_TYPE);
+		} else mediaTypesFinal = Array.from({ length: mediaCount }, () => DEFAULT_MEDIA_TYPE);
+		normalized.MediaTypes = mediaTypesFinal;
+		normalized.MediaType = mediaType ?? mediaTypesFinal[0] ?? DEFAULT_MEDIA_TYPE;
+	}
+	return normalized;
+}
+
+//#endregion
+export { inbound_context_exports as n, normalizeInboundTextNewlines as r, finalizeInboundContext as t };