silentlake 2026.3.24

package/dist/parse-finite-number-CP4MQF_w.js

@@ -0,0 +1,30 @@
+//#region src/infra/parse-finite-number.ts
+function normalizeNumericString(value) {
+	const trimmed = value.trim();
+	return trimmed ? trimmed : void 0;
+}
+function parseFiniteNumber(value) {
+	if (typeof value === "number" && Number.isFinite(value)) return value;
+	if (typeof value === "string") {
+		const parsed = Number.parseFloat(value);
+		if (Number.isFinite(parsed)) return parsed;
+	}
+}
+function parseStrictInteger(value) {
+	if (typeof value === "number") return Number.isSafeInteger(value) ? value : void 0;
+	if (typeof value !== "string") return;
+	const normalized = normalizeNumericString(value);
+	if (!normalized || !/^[+-]?\d+$/.test(normalized)) return;
+	const parsed = Number(normalized);
+	return Number.isSafeInteger(parsed) ? parsed : void 0;
+}
+function parseStrictPositiveInteger(value) {
+	const parsed = parseStrictInteger(value);
+	return parsed !== void 0 && parsed > 0 ? parsed : void 0;
+}
+function parseStrictNonNegativeInteger(value) {
+	const parsed = parseStrictInteger(value);
+	return parsed !== void 0 && parsed >= 0 ? parsed : void 0;
+}
+//#endregion
+export { parseStrictPositiveInteger as i, parseStrictInteger as n, parseStrictNonNegativeInteger as r, parseFiniteNumber as t };

package/dist/parse-log-line-CVh9zu3Q.js

@@ -0,0 +1,43 @@
+//#region src/logging/parse-log-line.ts
+function extractMessage(value) {
+	const parts = [];
+	for (const key of Object.keys(value)) {
+		if (!/^\d+$/.test(key)) continue;
+		const item = value[key];
+		if (typeof item === "string") parts.push(item);
+		else if (item != null) parts.push(JSON.stringify(item));
+	}
+	return parts.join(" ");
+}
+function parseMetaName(raw) {
+	if (typeof raw !== "string") return {};
+	try {
+		const parsed = JSON.parse(raw);
+		return {
+			subsystem: typeof parsed.subsystem === "string" ? parsed.subsystem : void 0,
+			module: typeof parsed.module === "string" ? parsed.module : void 0
+		};
+	} catch {
+		return {};
+	}
+}
+function parseLogLine(raw) {
+	try {
+		const parsed = JSON.parse(raw);
+		const meta = parsed._meta;
+		const nameMeta = parseMetaName(meta?.name);
+		const levelRaw = typeof meta?.logLevelName === "string" ? meta.logLevelName : void 0;
+		return {
+			time: typeof parsed.time === "string" ? parsed.time : typeof meta?.date === "string" ? meta.date : void 0,
+			level: levelRaw ? levelRaw.toLowerCase() : void 0,
+			subsystem: nameMeta.subsystem,
+			module: nameMeta.module,
+			message: extractMessage(parsed),
+			raw
+		};
+	} catch {
+		return null;
+	}
+}
+//#endregion
+export { parseLogLine as t };

package/dist/parse-port-COyt3COn.js

@@ -0,0 +1,8 @@
+import { i as parseStrictPositiveInteger } from "./parse-finite-number-CP4MQF_w.js";
+//#region src/cli/shared/parse-port.ts
+function parsePort(raw) {
+	if (raw === void 0 || raw === null) return null;
+	return parseStrictPositiveInteger(raw) ?? null;
+}
+//#endregion
+export { parsePort as t };

package/dist/path-alias-guards-ZTKqurNH.js

@@ -0,0 +1,40 @@
+import { n as resolveBoundaryPath, o as isNotFoundPathError, t as BOUNDARY_PATH_ALIAS_POLICIES } from "./boundary-path-B3FFLYNx.js";
+import os from "node:os";
+import fs from "node:fs/promises";
+//#region src/infra/hardlink-guards.ts
+async function assertNoHardlinkedFinalPath(params) {
+	if (params.allowFinalHardlinkForUnlink) return;
+	let stat;
+	try {
+		stat = await fs.stat(params.filePath);
+	} catch (err) {
+		if (isNotFoundPathError(err)) return;
+		throw err;
+	}
+	if (!stat.isFile()) return;
+	if (stat.nlink > 1) throw new Error(`Hardlinked path is not allowed under ${params.boundaryLabel} (${shortPath(params.root)}): ${shortPath(params.filePath)}`);
+}
+function shortPath(value) {
+	if (value.startsWith(os.homedir())) return `~${value.slice(os.homedir().length)}`;
+	return value;
+}
+//#endregion
+//#region src/infra/path-alias-guards.ts
+const PATH_ALIAS_POLICIES = BOUNDARY_PATH_ALIAS_POLICIES;
+async function assertNoPathAliasEscape(params) {
+	const resolved = await resolveBoundaryPath({
+		absolutePath: params.absolutePath,
+		rootPath: params.rootPath,
+		boundaryLabel: params.boundaryLabel,
+		policy: params.policy
+	});
+	if (params.policy?.allowFinalSymlinkForUnlink === true && resolved.kind === "symlink") return;
+	await assertNoHardlinkedFinalPath({
+		filePath: resolved.absolutePath,
+		root: resolved.rootPath,
+		boundaryLabel: params.boundaryLabel,
+		allowFinalHardlinkForUnlink: params.policy?.allowFinalHardlinkForUnlink
+	});
+}
+//#endregion
+export { assertNoPathAliasEscape as n, PATH_ALIAS_POLICIES as t };

package/dist/path-env-CPkz6U0Y.js

@@ -0,0 +1,87 @@
+import { t as isTruthyEnvValue } from "./env-BP70DGuy.js";
+import { n as resolveBrewPathDirs } from "./brew-DSwWqzLd.js";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+//#region src/infra/path-env.ts
+function isExecutable(filePath) {
+	try {
+		fs.accessSync(filePath, fs.constants.X_OK);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function isDirectory(dirPath) {
+	try {
+		return fs.statSync(dirPath).isDirectory();
+	} catch {
+		return false;
+	}
+}
+function mergePath(params) {
+	const partsExisting = params.existing.split(path.delimiter).map((part) => part.trim()).filter(Boolean);
+	const partsPrepend = (params.prepend ?? []).map((part) => part.trim()).filter(Boolean);
+	const partsAppend = (params.append ?? []).map((part) => part.trim()).filter(Boolean);
+	const seen = /* @__PURE__ */ new Set();
+	const merged = [];
+	for (const part of [
+		...partsPrepend,
+		...partsExisting,
+		...partsAppend
+	]) if (!seen.has(part)) {
+		seen.add(part);
+		merged.push(part);
+	}
+	return merged.join(path.delimiter);
+}
+function candidateBinDirs(opts) {
+	const execPath = opts.execPath ?? process.execPath;
+	const cwd = opts.cwd ?? process.cwd();
+	const homeDir = opts.homeDir ?? os.homedir();
+	const platform = opts.platform ?? process.platform;
+	const prepend = [];
+	const append = [];
+	try {
+		const execDir = path.dirname(execPath);
+		if (isExecutable(path.join(execDir, "openclaw"))) prepend.push(execDir);
+	} catch {}
+	if (opts.allowProjectLocalBin === true || isTruthyEnvValue(process.env.OPENCLAW_ALLOW_PROJECT_LOCAL_BIN)) {
+		const localBinDir = path.join(cwd, "node_modules", ".bin");
+		if (isExecutable(path.join(localBinDir, "openclaw"))) append.push(localBinDir);
+	}
+	const miseDataDir = process.env.MISE_DATA_DIR ?? path.join(homeDir, ".local", "share", "mise");
+	const miseShims = path.join(miseDataDir, "shims");
+	if (isDirectory(miseShims)) prepend.push(miseShims);
+	prepend.push(...resolveBrewPathDirs({ homeDir }));
+	if (platform === "darwin") prepend.push(path.join(homeDir, "Library", "pnpm"));
+	if (process.env.XDG_BIN_HOME) prepend.push(process.env.XDG_BIN_HOME);
+	prepend.push(path.join(homeDir, ".local", "bin"));
+	prepend.push(path.join(homeDir, ".local", "share", "pnpm"));
+	prepend.push(path.join(homeDir, ".bun", "bin"));
+	prepend.push(path.join(homeDir, ".yarn", "bin"));
+	prepend.push("/opt/homebrew/bin", "/usr/local/bin", "/usr/bin", "/bin");
+	return {
+		prepend: prepend.filter(isDirectory),
+		append: append.filter(isDirectory)
+	};
+}
+/**
+* Best-effort PATH bootstrap so skills that require the `openclaw` CLI can run
+* under launchd/minimal environments (and inside the macOS app bundle).
+*/
+function ensureOpenClawCliOnPath(opts = {}) {
+	if (isTruthyEnvValue(process.env.OPENCLAW_PATH_BOOTSTRAPPED)) return;
+	process.env.OPENCLAW_PATH_BOOTSTRAPPED = "1";
+	const existing = opts.pathEnv ?? process.env.PATH ?? "";
+	const { prepend, append } = candidateBinDirs(opts);
+	if (prepend.length === 0 && append.length === 0) return;
+	const merged = mergePath({
+		existing,
+		prepend,
+		append
+	});
+	if (merged) process.env.PATH = merged;
+}
+//#endregion
+export { ensureOpenClawCliOnPath as t };

package/dist/paths-CTjJI9l0.js

@@ -0,0 +1,179 @@
+import { C as resolveRequiredHomeDir, _ as resolveStateDir, v as expandHomePrefix } from "./paths-GHJ97ebE.js";
+import { c as normalizeAgentId, t as DEFAULT_AGENT_ID } from "./session-key-gFFk3uv9.js";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+//#region src/config/sessions/paths.ts
+function resolveAgentSessionsDir(agentId, env = process.env, homedir = () => resolveRequiredHomeDir(env, os.homedir)) {
+	const root = resolveStateDir(env, homedir);
+	const id = normalizeAgentId(agentId ?? "main");
+	return path.join(root, "agents", id, "sessions");
+}
+function resolveSessionTranscriptsDir(env = process.env, homedir = () => resolveRequiredHomeDir(env, os.homedir)) {
+	return resolveAgentSessionsDir(DEFAULT_AGENT_ID, env, homedir);
+}
+function resolveSessionTranscriptsDirForAgent(agentId, env = process.env, homedir = () => resolveRequiredHomeDir(env, os.homedir)) {
+	return resolveAgentSessionsDir(agentId, env, homedir);
+}
+function resolveDefaultSessionStorePath(agentId) {
+	return path.join(resolveAgentSessionsDir(agentId), "sessions.json");
+}
+const MULTI_STORE_PATH_SENTINEL = "(multiple)";
+function resolveSessionFilePathOptions(params) {
+	const agentId = params.agentId?.trim();
+	const storePath = params.storePath?.trim();
+	if (storePath && storePath !== MULTI_STORE_PATH_SENTINEL) {
+		const sessionsDir = path.dirname(path.resolve(storePath));
+		return agentId ? {
+			sessionsDir,
+			agentId
+		} : { sessionsDir };
+	}
+	if (agentId) return { agentId };
+}
+const SAFE_SESSION_ID_RE = /^[a-z0-9][a-z0-9._-]{0,127}$/i;
+function validateSessionId(sessionId) {
+	const trimmed = sessionId.trim();
+	if (!SAFE_SESSION_ID_RE.test(trimmed)) throw new Error(`Invalid session ID: ${sessionId}`);
+	return trimmed;
+}
+function resolveSessionsDir(opts) {
+	const sessionsDir = opts?.sessionsDir?.trim();
+	if (sessionsDir) return path.resolve(sessionsDir);
+	return resolveAgentSessionsDir(opts?.agentId);
+}
+function resolvePathFromAgentSessionsDir(agentSessionsDir, candidateAbsPath) {
+	const agentBase = safeRealpathSync(path.resolve(agentSessionsDir)) ?? path.resolve(agentSessionsDir);
+	const realCandidate = safeRealpathSync(candidateAbsPath) ?? candidateAbsPath;
+	const relative = path.relative(agentBase, realCandidate);
+	if (!relative || relative.startsWith("..") || path.isAbsolute(relative)) return;
+	return path.resolve(agentBase, relative);
+}
+function resolveSiblingAgentSessionsDir(baseSessionsDir, agentId) {
+	const resolvedBase = path.resolve(baseSessionsDir);
+	if (path.basename(resolvedBase) !== "sessions") return;
+	const baseAgentDir = path.dirname(resolvedBase);
+	const baseAgentsDir = path.dirname(baseAgentDir);
+	if (path.basename(baseAgentsDir) !== "agents") return;
+	const rootDir = path.dirname(baseAgentsDir);
+	return path.join(rootDir, "agents", normalizeAgentId(agentId), "sessions");
+}
+function resolveAgentSessionsPathParts(candidateAbsPath) {
+	const parts = path.normalize(path.resolve(candidateAbsPath)).split(path.sep).filter(Boolean);
+	const sessionsIndex = parts.lastIndexOf("sessions");
+	if (sessionsIndex < 2 || parts[sessionsIndex - 2] !== "agents") return null;
+	return {
+		parts,
+		sessionsIndex
+	};
+}
+function extractAgentIdFromAbsoluteSessionPath(candidateAbsPath) {
+	const parsed = resolveAgentSessionsPathParts(candidateAbsPath);
+	if (!parsed) return;
+	const { parts, sessionsIndex } = parsed;
+	return parts[sessionsIndex - 1] || void 0;
+}
+function resolveStructuralSessionFallbackPath(candidateAbsPath, expectedAgentId) {
+	const parsed = resolveAgentSessionsPathParts(candidateAbsPath);
+	if (!parsed) return;
+	const { parts, sessionsIndex } = parsed;
+	const agentIdPart = parts[sessionsIndex - 1];
+	if (!agentIdPart) return;
+	const normalizedAgentId = normalizeAgentId(agentIdPart);
+	if (normalizedAgentId !== agentIdPart.toLowerCase()) return;
+	if (normalizedAgentId !== normalizeAgentId(expectedAgentId)) return;
+	const relativeSegments = parts.slice(sessionsIndex + 1);
+	if (relativeSegments.length !== 1) return;
+	const fileName = relativeSegments[0];
+	if (!fileName || fileName === "." || fileName === "..") return;
+	return path.normalize(path.resolve(candidateAbsPath));
+}
+function safeRealpathSync(filePath) {
+	try {
+		return fs.realpathSync(filePath);
+	} catch {
+		return;
+	}
+}
+function resolvePathWithinSessionsDir(sessionsDir, candidate, opts) {
+	const trimmed = candidate.trim();
+	if (!trimmed) throw new Error("Session file path must not be empty");
+	const resolvedBase = path.resolve(sessionsDir);
+	const realBase = safeRealpathSync(resolvedBase) ?? resolvedBase;
+	const realTrimmed = path.isAbsolute(trimmed) ? safeRealpathSync(trimmed) ?? trimmed : trimmed;
+	const normalized = path.isAbsolute(realTrimmed) ? path.relative(realBase, realTrimmed) : realTrimmed;
+	if (normalized.startsWith("..") && path.isAbsolute(realTrimmed)) {
+		const tryAgentFallback = (agentId) => {
+			const normalizedAgentId = normalizeAgentId(agentId);
+			const siblingSessionsDir = resolveSiblingAgentSessionsDir(realBase, normalizedAgentId);
+			if (siblingSessionsDir) {
+				const siblingResolved = resolvePathFromAgentSessionsDir(siblingSessionsDir, realTrimmed);
+				if (siblingResolved) return siblingResolved;
+			}
+			return resolvePathFromAgentSessionsDir(resolveAgentSessionsDir(normalizedAgentId), realTrimmed);
+		};
+		const explicitAgentId = opts?.agentId?.trim();
+		if (explicitAgentId) {
+			const resolvedFromAgent = tryAgentFallback(explicitAgentId);
+			if (resolvedFromAgent) return resolvedFromAgent;
+		}
+		const extractedAgentId = extractAgentIdFromAbsoluteSessionPath(realTrimmed);
+		if (extractedAgentId) {
+			const resolvedFromPath = tryAgentFallback(extractedAgentId);
+			if (resolvedFromPath) return resolvedFromPath;
+			const structuralFallback = resolveStructuralSessionFallbackPath(realTrimmed, extractedAgentId);
+			if (structuralFallback) return structuralFallback;
+		}
+	}
+	if (!normalized || normalized.startsWith("..") || path.isAbsolute(normalized)) throw new Error("Session file path must be within sessions directory");
+	return path.resolve(realBase, normalized);
+}
+function resolveSessionTranscriptPathInDir(sessionId, sessionsDir, topicId) {
+	const safeSessionId = validateSessionId(sessionId);
+	const safeTopicId = typeof topicId === "string" ? encodeURIComponent(topicId) : typeof topicId === "number" ? String(topicId) : void 0;
+	return resolvePathWithinSessionsDir(sessionsDir, safeTopicId !== void 0 ? `${safeSessionId}-topic-${safeTopicId}.jsonl` : `${safeSessionId}.jsonl`);
+}
+function resolveSessionTranscriptPath(sessionId, agentId, topicId) {
+	return resolveSessionTranscriptPathInDir(sessionId, resolveAgentSessionsDir(agentId), topicId);
+}
+function resolveSessionFilePath(sessionId, entry, opts) {
+	const sessionsDir = resolveSessionsDir(opts);
+	const candidate = entry?.sessionFile?.trim();
+	if (candidate) try {
+		return resolvePathWithinSessionsDir(sessionsDir, candidate, { agentId: opts?.agentId });
+	} catch {}
+	return resolveSessionTranscriptPathInDir(sessionId, sessionsDir);
+}
+function resolveStorePath(store, opts) {
+	const agentId = normalizeAgentId(opts?.agentId ?? "main");
+	const env = opts?.env ?? process.env;
+	const homedir = () => resolveRequiredHomeDir(env, os.homedir);
+	if (!store) return path.join(resolveAgentSessionsDir(agentId, env, homedir), "sessions.json");
+	if (store.includes("{agentId}")) {
+		const expanded = store.replaceAll("{agentId}", agentId);
+		if (expanded.startsWith("~")) return path.resolve(expandHomePrefix(expanded, {
+			home: resolveRequiredHomeDir(env, homedir),
+			env,
+			homedir
+		}));
+		return path.resolve(expanded);
+	}
+	if (store.startsWith("~")) return path.resolve(expandHomePrefix(store, {
+		home: resolveRequiredHomeDir(env, homedir),
+		env,
+		homedir
+	}));
+	return path.resolve(store);
+}
+function resolveAgentsDirFromSessionStorePath(storePath) {
+	const candidateAbsPath = path.resolve(storePath);
+	if (path.basename(candidateAbsPath) !== "sessions.json") return;
+	const sessionsDir = path.dirname(candidateAbsPath);
+	if (path.basename(sessionsDir) !== "sessions") return;
+	const agentDir = path.dirname(sessionsDir);
+	const agentsDir = path.dirname(agentDir);
+	if (path.basename(agentsDir) !== "agents") return;
+	return agentsDir;
+}
+//#endregion
+export { resolveSessionTranscriptPath as a, resolveSessionTranscriptsDirForAgent as c, resolveSessionFilePathOptions as i, resolveStorePath as l, resolveDefaultSessionStorePath as n, resolveSessionTranscriptPathInDir as o, resolveSessionFilePath as r, resolveSessionTranscriptsDir as s, resolveAgentsDirFromSessionStorePath as t };

package/dist/paths-GHJ97ebE.js

@@ -0,0 +1,268 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+//#region src/infra/home-dir.ts
+function normalize(value) {
+	const trimmed = value?.trim();
+	return trimmed ? trimmed : void 0;
+}
+function resolveEffectiveHomeDir(env = process.env, homedir = os.homedir) {
+	const raw = resolveRawHomeDir(env, homedir);
+	return raw ? path.resolve(raw) : void 0;
+}
+function resolveOsHomeDir(env = process.env, homedir = os.homedir) {
+	const raw = resolveRawOsHomeDir(env, homedir);
+	return raw ? path.resolve(raw) : void 0;
+}
+function resolveRawHomeDir(env, homedir) {
+	const explicitHome = normalize(env.OPENCLAW_HOME);
+	if (explicitHome) {
+		if (explicitHome === "~" || explicitHome.startsWith("~/") || explicitHome.startsWith("~\\")) {
+			const fallbackHome = resolveRawOsHomeDir(env, homedir);
+			if (fallbackHome) return explicitHome.replace(/^~(?=$|[\\/])/, fallbackHome);
+			return;
+		}
+		return explicitHome;
+	}
+	return resolveRawOsHomeDir(env, homedir);
+}
+function resolveRawOsHomeDir(env, homedir) {
+	const envHome = normalize(env.HOME);
+	if (envHome) return envHome;
+	const userProfile = normalize(env.USERPROFILE);
+	if (userProfile) return userProfile;
+	return normalizeSafe(homedir);
+}
+function normalizeSafe(homedir) {
+	try {
+		return normalize(homedir());
+	} catch {
+		return;
+	}
+}
+function resolveRequiredHomeDir(env = process.env, homedir = os.homedir) {
+	return resolveEffectiveHomeDir(env, homedir) ?? path.resolve(process.cwd());
+}
+function resolveRequiredOsHomeDir(env = process.env, homedir = os.homedir) {
+	return resolveOsHomeDir(env, homedir) ?? path.resolve(process.cwd());
+}
+function expandHomePrefix(input, opts) {
+	if (!input.startsWith("~")) return input;
+	const home = normalize(opts?.home) ?? resolveEffectiveHomeDir(opts?.env ?? process.env, opts?.homedir ?? os.homedir);
+	if (!home) return input;
+	return input.replace(/^~(?=$|[\\/])/, home);
+}
+function resolveHomeRelativePath(input, opts) {
+	const trimmed = input.trim();
+	if (!trimmed) return trimmed;
+	if (trimmed.startsWith("~")) {
+		const expanded = expandHomePrefix(trimmed, {
+			home: resolveRequiredHomeDir(opts?.env ?? process.env, opts?.homedir ?? os.homedir),
+			env: opts?.env,
+			homedir: opts?.homedir
+		});
+		return path.resolve(expanded);
+	}
+	return path.resolve(trimmed);
+}
+function resolveOsHomeRelativePath(input, opts) {
+	const trimmed = input.trim();
+	if (!trimmed) return trimmed;
+	if (trimmed.startsWith("~")) {
+		const expanded = expandHomePrefix(trimmed, {
+			home: resolveRequiredOsHomeDir(opts?.env ?? process.env, opts?.homedir ?? os.homedir),
+			env: opts?.env,
+			homedir: opts?.homedir
+		});
+		return path.resolve(expanded);
+	}
+	return path.resolve(trimmed);
+}
+//#endregion
+//#region src/config/paths.ts
+/**
+* Nix mode detection: When OPENCLAW_NIX_MODE=1, the gateway is running under Nix.
+* In this mode:
+* - No auto-install flows should be attempted
+* - Missing dependencies should produce actionable Nix-specific error messages
+* - Config is managed externally (read-only from Nix perspective)
+*/
+function resolveIsNixMode(env = process.env) {
+	return env.OPENCLAW_NIX_MODE === "1";
+}
+const isNixMode = resolveIsNixMode();
+const LEGACY_STATE_DIRNAMES = [
+	".clawdbot",
+	".moldbot",
+	".moltbot"
+];
+const NEW_STATE_DIRNAME = ".openclaw";
+const CONFIG_FILENAME = "openclaw.json";
+const LEGACY_CONFIG_FILENAMES = [
+	"clawdbot.json",
+	"moldbot.json",
+	"moltbot.json"
+];
+function resolveDefaultHomeDir() {
+	return resolveRequiredHomeDir(process.env, os.homedir);
+}
+/** Build a homedir thunk that respects OPENCLAW_HOME for the given env. */
+function envHomedir(env) {
+	return () => resolveRequiredHomeDir(env, os.homedir);
+}
+function legacyStateDirs(homedir = resolveDefaultHomeDir) {
+	return LEGACY_STATE_DIRNAMES.map((dir) => path.join(homedir(), dir));
+}
+function newStateDir(homedir = resolveDefaultHomeDir) {
+	return path.join(homedir(), NEW_STATE_DIRNAME);
+}
+function resolveLegacyStateDir(homedir = resolveDefaultHomeDir) {
+	return legacyStateDirs(homedir)[0] ?? newStateDir(homedir);
+}
+function resolveLegacyStateDirs(homedir = resolveDefaultHomeDir) {
+	return legacyStateDirs(homedir);
+}
+function resolveNewStateDir(homedir = resolveDefaultHomeDir) {
+	return newStateDir(homedir);
+}
+/**
+* State directory for mutable data (sessions, logs, caches).
+* Can be overridden via OPENCLAW_STATE_DIR.
+* Default: ~/.openclaw
+*/
+function resolveStateDir(env = process.env, homedir = envHomedir(env)) {
+	const effectiveHomedir = () => resolveRequiredHomeDir(env, homedir);
+	const override = env.OPENCLAW_STATE_DIR?.trim() || env.CLAWDBOT_STATE_DIR?.trim();
+	if (override) return resolveUserPath(override, env, effectiveHomedir);
+	const newDir = newStateDir(effectiveHomedir);
+	if (env.OPENCLAW_TEST_FAST === "1") return newDir;
+	const legacyDirs = legacyStateDirs(effectiveHomedir);
+	if (fs.existsSync(newDir)) return newDir;
+	const existingLegacy = legacyDirs.find((dir) => {
+		try {
+			return fs.existsSync(dir);
+		} catch {
+			return false;
+		}
+	});
+	if (existingLegacy) return existingLegacy;
+	return newDir;
+}
+function resolveUserPath(input, env = process.env, homedir = envHomedir(env)) {
+	return resolveHomeRelativePath(input, {
+		env,
+		homedir
+	});
+}
+const STATE_DIR = resolveStateDir();
+/**
+* Config file path (JSON or JSON5).
+* Can be overridden via OPENCLAW_CONFIG_PATH.
+* Default: ~/.openclaw/openclaw.json (or $OPENCLAW_STATE_DIR/openclaw.json)
+*/
+function resolveCanonicalConfigPath(env = process.env, stateDir = resolveStateDir(env, envHomedir(env))) {
+	const override = env.OPENCLAW_CONFIG_PATH?.trim() || env.CLAWDBOT_CONFIG_PATH?.trim();
+	if (override) return resolveUserPath(override, env, envHomedir(env));
+	return path.join(stateDir, CONFIG_FILENAME);
+}
+/**
+* Resolve the active config path by preferring existing config candidates
+* before falling back to the canonical path.
+*/
+function resolveConfigPathCandidate(env = process.env, homedir = envHomedir(env)) {
+	if (env.OPENCLAW_TEST_FAST === "1") return resolveCanonicalConfigPath(env, resolveStateDir(env, homedir));
+	const existing = resolveDefaultConfigCandidates(env, homedir).find((candidate) => {
+		try {
+			return fs.existsSync(candidate);
+		} catch {
+			return false;
+		}
+	});
+	if (existing) return existing;
+	return resolveCanonicalConfigPath(env, resolveStateDir(env, homedir));
+}
+/**
+* Active config path (prefers existing config files).
+*/
+function resolveConfigPath(env = process.env, stateDir = resolveStateDir(env, envHomedir(env)), homedir = envHomedir(env)) {
+	const override = env.OPENCLAW_CONFIG_PATH?.trim();
+	if (override) return resolveUserPath(override, env, homedir);
+	if (env.OPENCLAW_TEST_FAST === "1") return path.join(stateDir, CONFIG_FILENAME);
+	const stateOverride = env.OPENCLAW_STATE_DIR?.trim();
+	const existing = [path.join(stateDir, CONFIG_FILENAME), ...LEGACY_CONFIG_FILENAMES.map((name) => path.join(stateDir, name))].find((candidate) => {
+		try {
+			return fs.existsSync(candidate);
+		} catch {
+			return false;
+		}
+	});
+	if (existing) return existing;
+	if (stateOverride) return path.join(stateDir, CONFIG_FILENAME);
+	const defaultStateDir = resolveStateDir(env, homedir);
+	if (path.resolve(stateDir) === path.resolve(defaultStateDir)) return resolveConfigPathCandidate(env, homedir);
+	return path.join(stateDir, CONFIG_FILENAME);
+}
+const CONFIG_PATH = resolveConfigPathCandidate();
+/**
+* Resolve default config path candidates across default locations.
+* Order: explicit config path → state-dir-derived paths → new default.
+*/
+function resolveDefaultConfigCandidates(env = process.env, homedir = envHomedir(env)) {
+	const effectiveHomedir = () => resolveRequiredHomeDir(env, homedir);
+	const explicit = env.OPENCLAW_CONFIG_PATH?.trim() || env.CLAWDBOT_CONFIG_PATH?.trim();
+	if (explicit) return [resolveUserPath(explicit, env, effectiveHomedir)];
+	const candidates = [];
+	const openclawStateDir = env.OPENCLAW_STATE_DIR?.trim() || env.CLAWDBOT_STATE_DIR?.trim();
+	if (openclawStateDir) {
+		const resolved = resolveUserPath(openclawStateDir, env, effectiveHomedir);
+		candidates.push(path.join(resolved, CONFIG_FILENAME));
+		candidates.push(...LEGACY_CONFIG_FILENAMES.map((name) => path.join(resolved, name)));
+	}
+	const defaultDirs = [newStateDir(effectiveHomedir), ...legacyStateDirs(effectiveHomedir)];
+	for (const dir of defaultDirs) {
+		candidates.push(path.join(dir, CONFIG_FILENAME));
+		candidates.push(...LEGACY_CONFIG_FILENAMES.map((name) => path.join(dir, name)));
+	}
+	return candidates;
+}
+const DEFAULT_GATEWAY_PORT = 18789;
+/**
+* Gateway lock directory (ephemeral).
+* Default: os.tmpdir()/openclaw-<uid> (uid suffix when available).
+*/
+function resolveGatewayLockDir(tmpdir = os.tmpdir) {
+	const base = tmpdir();
+	const uid = typeof process.getuid === "function" ? process.getuid() : void 0;
+	const suffix = uid != null ? `openclaw-${uid}` : "openclaw";
+	return path.join(base, suffix);
+}
+const OAUTH_FILENAME = "oauth.json";
+/**
+* OAuth credentials storage directory.
+*
+* Precedence:
+* - `OPENCLAW_OAUTH_DIR` (explicit override)
+* - `$*_STATE_DIR/credentials` (canonical server/default)
+*/
+function resolveOAuthDir(env = process.env, stateDir = resolveStateDir(env, envHomedir(env))) {
+	const override = env.OPENCLAW_OAUTH_DIR?.trim();
+	if (override) return resolveUserPath(override, env, envHomedir(env));
+	return path.join(stateDir, "credentials");
+}
+function resolveOAuthPath(env = process.env, stateDir = resolveStateDir(env, envHomedir(env))) {
+	return path.join(resolveOAuthDir(env, stateDir), OAUTH_FILENAME);
+}
+function resolveGatewayPort(cfg, env = process.env) {
+	const envRaw = env.OPENCLAW_GATEWAY_PORT?.trim() || env.CLAWDBOT_GATEWAY_PORT?.trim();
+	if (envRaw) {
+		const parsed = Number.parseInt(envRaw, 10);
+		if (Number.isFinite(parsed) && parsed > 0) return parsed;
+	}
+	const configPort = cfg?.gateway?.port;
+	if (typeof configPort === "number" && Number.isFinite(configPort)) {
+		if (configPort > 0) return configPort;
+	}
+	return DEFAULT_GATEWAY_PORT;
+}
+//#endregion
+export { resolveRequiredHomeDir as C, resolveOsHomeRelativePath as S, resolveStateDir as _, resolveCanonicalConfigPath as a, resolveHomeRelativePath as b, resolveDefaultConfigCandidates as c, resolveIsNixMode as d, resolveLegacyStateDir as f, resolveOAuthPath as g, resolveOAuthDir as h, isNixMode as i, resolveGatewayLockDir as l, resolveNewStateDir as m, DEFAULT_GATEWAY_PORT as n, resolveConfigPath as o, resolveLegacyStateDirs as p, STATE_DIR as r, resolveConfigPathCandidate as s, CONFIG_PATH as t, resolveGatewayPort as u, expandHomePrefix as v, resolveRequiredOsHomeDir as w, resolveOsHomeDir as x, resolveEffectiveHomeDir as y };