@openclaw/acpx 2026.9.7 → 2026.9.8

package/README.md

@@ -12,6 +12,12 @@ openclaw plugins install @openclaw/acpx
 
 Restart the Gateway after installing or updating the plugin.
 
+The generated Codex and Claude ACP wrappers prefer the installed adapter while its
+entry file exists. If plugin capture cleanup removes that file, the next launch
+uses the existing pinned `npm exec` / `npx` fallback. This may require registry
+access when the pinned package is not cached. Restart the Gateway after updating
+to regenerate wrappers written by an older plugin version.
+
 ## What it provides
 
 - ACP-backed agent runtime sessions.

package/dist/.setup/{command-line-CPBLOiZM.mjs → command-line-B72femaL.mjs}

@@ -1,3 +1,4 @@
+import { normalizeOptionalLowercaseString } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/acpx/src/codex-adapter.ts
 const CODEX_ACP_PACKAGE = "@agentclientprotocol/codex-acp";
 const CODEX_ACP_BIN = "codex-acp";
@@ -66,10 +67,6 @@ function splitCommandParts(value) {
 }
 const OPENCLAW_BRIDGE_EXECUTABLE = "openclaw";
 const OPENCLAW_BRIDGE_SUBCOMMAND = "acp";
-function normalizeAgentName(value) {
-	const normalized = value?.trim().toLowerCase();
-	return normalized ? normalized : void 0;
-}
 function basename(value) {
 	return value.split(/[\\/]/).pop() ?? value;
 }
@@ -130,9 +127,9 @@ function isClaudeAcpCommand(command) {
 	});
 }
 function resolveAgentCommand(params) {
-	const normalizedAgentName = normalizeAgentName(params.agentName);
+	const normalizedAgentName = normalizeOptionalLowercaseString(params.agentName);
 	if (!normalizedAgentName) return;
 	return splitCommandParts(params.agentRegistry.resolve(normalizedAgentName));
 }
 //#endregion
-export { renderAgentCommand as a, CODEX_ACP_BIN as c, OPENCLAW_CODEX_CONFIG_ARG as d, normalizeAgentName as i, CODEX_ACP_PACKAGE as l, isCodexAcpCommand as n, resolveAgentCommand as o, isOpenClawBridgeCommand as r, splitCommandParts as s, isClaudeAcpCommand as t, LEGACY_CODEX_ACP_PACKAGE as u };
+export { resolveAgentCommand as a, CODEX_ACP_PACKAGE as c, renderAgentCommand as i, LEGACY_CODEX_ACP_PACKAGE as l, isCodexAcpCommand as n, splitCommandParts as o, isOpenClawBridgeCommand as r, CODEX_ACP_BIN as s, isClaudeAcpCommand as t, OPENCLAW_CODEX_CONFIG_ARG as u };

package/dist/.setup/{config-CdPsIued.mjs → config-Blz15uwJ.mjs}

@@ -1,10 +1,11 @@
-import { s as splitCommandParts } from "./command-line-CPBLOiZM.mjs";
+import { o as splitCommandParts } from "./command-line-B72femaL.mjs";
 import { createRequire } from "node:module";
 import { z } from "zod";
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { formatPluginConfigIssue } from "openclaw/plugin-sdk/extension-shared";
+import { resolveStateDir } from "openclaw/plugin-sdk/state-paths";
 import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/acpx/src/config-schema.ts
 /**
@@ -57,12 +58,15 @@ const AcpxPluginConfigSchema = z.strictObject({
 });
 //#endregion
 //#region extensions/acpx/src/config.ts
-/**
-* Resolves ACPX plugin config from raw user configuration. It locates the
-* plugin root, injects optional MCP bridge servers, and applies runtime defaults.
-*/
-const ACPX_PLUGIN_TOOLS_MCP_SERVER_NAME = "openclaw-plugin-tools";
-const ACPX_OPENCLAW_TOOLS_MCP_SERVER_NAME = "openclaw-tools";
+const MANAGED_MCP_BRIDGES = [[
+	"pluginToolsMcpBridge",
+	"openclaw-plugin-tools",
+	"plugin-tools-serve"
+], [
+	"openClawToolsMcpBridge",
+	"openclaw-tools",
+	"openclaw-tools-serve"
+]];
 const requireFromHere = createRequire(import.meta.url);
 function isAcpxPluginRoot(dir) {
 	return fs.existsSync(path.join(dir, "openclaw.plugin.json")) && fs.existsSync(path.join(dir, "package.json"));
@@ -142,13 +146,10 @@ function resolveManagedToolsMcpServerConfig(entryPoint, moduleUrl = import.meta.
 }
 function resolveConfiguredMcpServers(params) {
 	const resolved = { ...params.mcpServers };
-	if (params.pluginToolsMcpBridge && resolved[ACPX_PLUGIN_TOOLS_MCP_SERVER_NAME]) throw new Error(`mcpServers.${ACPX_PLUGIN_TOOLS_MCP_SERVER_NAME} is reserved when pluginToolsMcpBridge=true`);
-	if (params.openClawToolsMcpBridge && resolved[ACPX_OPENCLAW_TOOLS_MCP_SERVER_NAME]) throw new Error(`mcpServers.${ACPX_OPENCLAW_TOOLS_MCP_SERVER_NAME} is reserved when openClawToolsMcpBridge=true`);
-	if (params.pluginToolsMcpBridge) resolved[ACPX_PLUGIN_TOOLS_MCP_SERVER_NAME] = resolveManagedToolsMcpServerConfig("plugin-tools-serve", params.moduleUrl);
-	if (params.openClawToolsMcpBridge) resolved[ACPX_OPENCLAW_TOOLS_MCP_SERVER_NAME] = resolveManagedToolsMcpServerConfig("openclaw-tools-serve", params.moduleUrl);
+	for (const [flag, name] of MANAGED_MCP_BRIDGES) if (params[flag] && resolved[name]) throw new Error(`mcpServers.${name} is reserved when ${flag}=true`);
+	for (const [flag, name, entryPoint] of MANAGED_MCP_BRIDGES) if (params[flag]) resolved[name] = resolveManagedToolsMcpServerConfig(entryPoint, params.moduleUrl);
 	return resolved;
 }
-/** Convert OpenClaw MCP server config into ACPX runtime MCP server entries. */
 function toAcpMcpServers(mcpServers) {
 	return Object.entries(mcpServers).map(([name, server]) => ({
 		name,
@@ -160,15 +161,14 @@ function toAcpMcpServers(mcpServers) {
 		}))
 	}));
 }
-/** Validate and normalize raw ACPX plugin config for runtime startup. */
 function resolveAcpxPluginConfig(params) {
 	const { rawConfig } = params;
 	const parsed = AcpxPluginConfigSchema.safeParse(rawConfig === void 0 ? {} : rawConfig);
 	if (!parsed.success) throw new Error(formatPluginConfigIssue(parsed.error.issues[0]));
 	const normalized = parsed.data;
 	const workspaceDir = params.workspaceDir?.trim() || process.cwd();
-	const cwd = path.resolve(normalized.cwd?.trim() || workspaceDir);
-	const stateDir = path.resolve(normalized.stateDir?.trim() || path.join(workspaceDir, "state"));
+	const cwd = path.resolve(normalized.cwd ?? workspaceDir);
+	const stateDir = path.resolve(normalized.stateDir ?? path.join(params.stateDir ?? resolveStateDir(), "acpx"));
 	const pluginToolsMcpBridge = normalized.pluginToolsMcpBridge === true;
 	const openClawToolsMcpBridge = normalized.openClawToolsMcpBridge === true;
 	const mcpServers = resolveConfiguredMcpServers({

package/dist/.setup/{pi-session-catalog-runtime-UhiQSaDw.mjs → pi-session-catalog-runtime-IKEanK3s.mjs}

@@ -1,5 +1,5 @@
 import { c as PI_SESSION_READ_COMMAND, i as PI_LOCAL_SESSION_HOST_ID, l as PI_TERMINAL_RESUME_COMMAND, n as piSessionStore, o as PI_SESSIONS_LIST_COMMAND, r as piSessionStoreAvailable, s as PI_SESSION_ID_PATTERN, t as piAcpSessionStoreRoot } from "./pi-session-paths-CIvyk6KB.mjs";
-import { parseDateFirstTimestampMs } from "openclaw/plugin-sdk/number-runtime";
+import { parseDateFirstTimestampMs, timestampMsToIsoString } from "openclaw/plugin-sdk/number-runtime";
 import { createReadStream } from "node:fs";
 import path from "node:path";
 import { isRecord, normalizeBoundedOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
@@ -10,15 +10,9 @@ import { resolveAcpSessionAvailability } from "openclaw/plugin-sdk/acp-runtime";
 import process from "node:process";
 import { resolveSessionAgentIdsStrict } from "openclaw/plugin-sdk/agent-scope-runtime";
 import { sessionCatalogPaging } from "openclaw/plugin-sdk/session-catalog-paging";
-import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
+import { safeParseJson, truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import { runTasksWithConcurrency } from "openclaw/plugin-sdk/concurrency-runtime";
 import { isPathStrictlyInside, readFileRangeAsync } from "openclaw/plugin-sdk/file-access-runtime";
-//#region extensions/acpx/src/pi-session-timestamp.ts
-/** Preserve Pi JSONL's date-first string contract while accepting numeric millisecond values. */
-function parsePiSessionTimestampMs(value) {
-	return parseDateFirstTimestampMs(value);
-}
-//#endregion
 //#region extensions/acpx/src/pi-session-store.ts
 const MAX_DISCOVERY_FILES = 1e4;
 const SUMMARY_SCAN_BATCH_SIZE = 100;
@@ -29,7 +23,6 @@ const APPEND_PROOF_EDGE_BYTES = 65536;
 const IO_CONCURRENCY = 8;
 const PI_FILE_CANDIDATE_CACHE_TTL_MS = 32e3;
 const PI_FILE_CANDIDATE_CACHE_MAX_ENTRIES = 8;
-const SESSION_ID_PATTERN = /^(?!-)[A-Za-z0-9._:-]{1,256}$/u;
 const summaryCache = /* @__PURE__ */ new Map();
 const threadFileCache = /* @__PURE__ */ new Map();
 const piFileCandidateCache = /* @__PURE__ */ new Map();
@@ -153,15 +146,11 @@ async function piFileCandidates(env) {
 function parsePiJsonLines(content) {
 	return content.split(/\r?\n/u).flatMap((line) => {
 		if (!line.trim()) return [];
-		try {
-			const value = JSON.parse(line);
-			return isRecord(value) ? [value] : [];
-		} catch {
-			return [];
-		}
+		const value = safeParseJson(line);
+		return isRecord(value) ? [value] : [];
 	});
 }
-function textFromContent$2(content) {
+function piMessageText(content) {
 	if (typeof content === "string") return content;
 	if (!Array.isArray(content)) return "";
 	return content.flatMap((part) => isRecord(part) && part.type === "text" && typeof part.text === "string" ? [part.text] : []).join("\n");
@@ -178,7 +167,7 @@ function processSummaryLine(state, line) {
 		return;
 	}
 	if (entry.type === "session_info") state.name = normalizeBoundedOptionalString(entry.name, 1e3);
-	else if (!state.firstMessage && entry.type === "message" && isRecord(entry.message) && entry.message.role === "user") state.firstMessage = normalizeBoundedOptionalString(textFromContent$2(entry.message.content), 1e3);
+	else if (!state.firstMessage && entry.type === "message" && isRecord(entry.message) && entry.message.role === "user") state.firstMessage = normalizeBoundedOptionalString(piMessageText(entry.message.content), 1e3);
 }
 function appendSummaryBytes(state, bytes) {
 	if (state.discarding || bytes.length === 0) return;
@@ -268,9 +257,9 @@ async function readPiSessionSummary(candidate) {
 		const { header, name, firstMessage } = projectedState;
 		const version = header?.type === "session" && typeof header.version === "number" ? header.version : 1;
 		const threadId = header?.type === "session" ? normalizeBoundedOptionalString(header.id, 256) : void 0;
-		if (header && threadId && SESSION_ID_PATTERN.test(threadId)) {
+		if (header && threadId && PI_SESSION_ID_PATTERN.test(threadId)) {
 			const cwd = normalizeBoundedOptionalString(header.cwd, 4096);
-			const createdAt = parsePiSessionTimestampMs(header.timestamp);
+			const createdAt = parseDateFirstTimestampMs(header.timestamp);
 			summary = {
 				file: candidate.file,
 				version,
@@ -383,7 +372,7 @@ async function readPiSessionById(threadId, env) {
 //#region extensions/acpx/src/pi-session-catalog.ts
 const MAX_SEARCH_LENGTH = 500;
 const isExactPiSessionCursor = sessionCatalogPaging.isExactCursor;
-function textFromContent$1(content) {
+function textFromContent(content) {
 	if (typeof content === "string") return content;
 	if (!Array.isArray(content)) return "";
 	return content.flatMap((part) => {
@@ -421,12 +410,6 @@ async function listLocalPiSessionPage(value) {
 		...hasMore ? { nextCursor: sessionCatalogPaging.encodeCursor(offset + page.length) } : {}
 	};
 }
-function isoTimestamp(message, entry) {
-	const value = parsePiSessionTimestampMs(message.timestamp) ?? parsePiSessionTimestampMs(entry.timestamp);
-	if (value === void 0) return;
-	const date = new Date(value);
-	return Number.isNaN(date.getTime()) ? void 0 : date.toISOString();
-}
 function jsonText(value, maxLength = 2e4) {
 	try {
 		const text = JSON.stringify(value);
@@ -458,7 +441,7 @@ function piMessageItems(entry) {
 	const message = entry.message;
 	const role = message.role;
 	const id = normalizeBoundedOptionalString(entry.id, 256);
-	const timestamp = isoTimestamp(message, entry);
+	const timestamp = timestampMsToIsoString(parseDateFirstTimestampMs(message.timestamp) ?? parseDateFirstTimestampMs(entry.timestamp));
 	const model = normalizeBoundedOptionalString(message.model, 256);
 	const provider = normalizeBoundedOptionalString(message.provider, 256);
 	const modelRef = provider && model ? `${provider}/${model}` : model;
@@ -468,7 +451,7 @@ function piMessageItems(entry) {
 		...modelRef ? { model: modelRef } : {}
 	};
 	if (role === "user") {
-		const text = textFromContent$1(message.content);
+		const text = textFromContent(message.content);
 		return text ? [{
 			...common,
 			type: "userMessage",
@@ -477,7 +460,7 @@ function piMessageItems(entry) {
 	}
 	if (role === "toolResult") {
 		const toolName = normalizeBoundedOptionalString(message.toolName, 256);
-		const text = textFromContent$1(message.content);
+		const text = textFromContent(message.content);
 		return [{
 			...common,
 			type: "toolResult",
@@ -502,7 +485,7 @@ function piMessageItems(entry) {
 	if (role === "custom" || role === "hookMessage") {
 		if (message.display !== true) return [];
 		const customType = normalizeBoundedOptionalString(message.customType, 256);
-		const text = textFromContent$1(message.content);
+		const text = textFromContent(message.content);
 		return text ? [{
 			...common,
 			type: "other",
@@ -547,18 +530,13 @@ function piTranscriptItems(entries) {
 			...id ? { id } : {},
 			...timestamp ? { timestamp } : {}
 		};
-		if (entry.type === "compaction" && typeof entry.summary === "string") return [{
-			...common,
-			type: "other",
-			text: entry.summary
-		}];
-		if (entry.type === "branch_summary" && typeof entry.summary === "string") return [{
+		if ((entry.type === "compaction" || entry.type === "branch_summary") && typeof entry.summary === "string") return [{
 			...common,
 			type: "other",
 			text: entry.summary
 		}];
 		if (entry.type === "custom_message" && entry.display === true) {
-			const text = textFromContent$1(entry.content);
+			const text = textFromContent(entry.content);
 			return text ? [{
 				...common,
 				type: "other",
@@ -594,12 +572,10 @@ function parseCompletePiRows(tail) {
 	for (let index = 0; index < tail.length; index += 1) {
 		if (tail[index] !== 10) continue;
 		const line = tail.subarray(lineStart, index).toString("utf8").trim();
-		if (line) try {
-			const value = JSON.parse(line);
+		if (line) {
+			const value = safeParseJson(line);
 			if (!isRecord(value)) break;
 			entries.push(value);
-		} catch {
-			break;
 		}
 		classifiedBytes = index + 1;
 		lineStart = index + 1;
@@ -609,11 +585,6 @@ function parseCompletePiRows(tail) {
 		classifiedBytes
 	};
 }
-function textFromContent(content) {
-	if (typeof content === "string") return content;
-	if (!Array.isArray(content)) return;
-	return content.flatMap((part) => isRecord(part) && part.type === "text" && typeof part.text === "string" ? [part.text] : []).join("\n") || void 0;
-}
 function readFilePath(probe) {
 	return isRecord(probe.upstreamRef) && typeof probe.upstreamRef.filePath === "string" ? probe.upstreamRef.filePath : void 0;
 }
@@ -663,10 +634,10 @@ async function checkPiSessionUpstreamActivity(probe) {
 		let occurredAt;
 		for (const entry of entries) {
 			if (entry.type !== "message" || !isRecord(entry.message) || entry.message.role !== "user") continue;
-			const text = textFromContent(entry.message.content);
+			const text = piMessageText(entry.message.content);
 			if (!isExternalUserText(probe, text)) continue;
 			humanTurns += 1;
-			occurredAt = Math.max(occurredAt ?? 0, parsePiSessionTimestampMs(entry.message.timestamp) ?? parsePiSessionTimestampMs(entry.timestamp) ?? stat.mtimeMs);
+			occurredAt = Math.max(occurredAt ?? 0, parseDateFirstTimestampMs(entry.message.timestamp) ?? parseDateFirstTimestampMs(entry.timestamp) ?? stat.mtimeMs);
 		}
 		const nextOffset = markerOffset + classifiedBytes;
 		return {
@@ -781,12 +752,6 @@ async function createAdoptedPiSession(params) {
 function assertPiLocalAccess(hostId, allowProcessHomeFallback) {
 	if (hostId === "gateway" && allowProcessHomeFallback === false && piSessionStore(process.env).usesProcessHomeFallback) throw new Error("local Pi sessions are unavailable in isolated state");
 }
-async function listPiSessions(params) {
-	return await listLocalPiSessionPage(params);
-}
-async function readPiSession(params) {
-	return await readLocalPiTranscriptPage(params);
-}
 function createPiSessionCatalogRuntime(api) {
 	return createSessionCatalogFamily({
 		runtime: api.runtime,
@@ -880,4 +845,4 @@ function createPiSessionCatalogRuntime(api) {
 	}, isExactPiSessionCursor);
 }
 //#endregion
-export { createPiSessionCatalogRuntime, listPiSessions, readPiSession, requireLocalPiSession };
+export { createPiSessionCatalogRuntime, listLocalPiSessionPage as listPiSessions, readLocalPiTranscriptPage as readPiSession, requireLocalPiSession };

package/dist/.setup/process-lease-n38HFGdp.mjs

@@ -0,0 +1,311 @@
+import { i as renderAgentCommand, o as splitCommandParts } from "./command-line-B72femaL.mjs";
+import "node:module";
+import { asFiniteNumber, asOptionalObjectRecord, asRecord, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { createHash } from "node:crypto";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+//#endregion
+//#region packages/normalization-core/src/record-coerce.ts
+/** Type guard for non-array object records at browser-safe boundaries. */
+function isRecord$1(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+/** Returns a non-array record or null. */
+function asNullableRecord(value) {
+	return isRecord$1(value) ? value : null;
+}
+//#endregion
+//#region src/config/channel-config-normalization.ts
+/** Applies one channel-specific doctor migration to every object-shaped account. */
+function normalizeChannelAccounts(params) {
+	const rawAccounts = asNullableRecord(params.entry.accounts);
+	if (!rawAccounts) return {
+		entry: params.entry,
+		changed: false
+	};
+	let changed = false;
+	const accounts = { ...rawAccounts };
+	for (const [accountId, value] of Object.entries(rawAccounts)) {
+		const account = asNullableRecord(value);
+		if (!account) continue;
+		const normalized = params.normalizeAccount({
+			account,
+			accountId,
+			pathPrefix: `${params.pathPrefix}.accounts.${accountId}`,
+			changes: params.changes
+		});
+		if (normalized.changed) {
+			accounts[accountId] = normalized.entry;
+			changed = true;
+		}
+	}
+	return changed ? {
+		entry: {
+			...params.entry,
+			accounts
+		},
+		changed: true
+	} : {
+		entry: params.entry,
+		changed: false
+	};
+}
+/** Applies the same channel-specific doctor migration at root and account scope. */
+function normalizeChannelConfigEntries(params) {
+	const changes = params.changes ?? [];
+	const channels = params.cfg.channels;
+	const entry = asNullableRecord(channels?.[params.channelId]);
+	if (!entry) return {
+		config: params.cfg,
+		changes
+	};
+	const channelPath = `channels.${params.channelId}`;
+	const root = params.normalizeEntry({
+		entry,
+		pathPrefix: channelPath,
+		changes
+	});
+	const accounts = normalizeChannelAccounts({
+		entry: root.entry,
+		pathPrefix: channelPath,
+		changes,
+		normalizeAccount: (accountParams) => params.normalizeEntry({
+			entry: accountParams.account,
+			accountId: accountParams.accountId,
+			pathPrefix: accountParams.pathPrefix,
+			changes: accountParams.changes
+		})
+	});
+	if (!root.changed && !accounts.changed) return {
+		config: params.cfg,
+		changes
+	};
+	return {
+		config: {
+			...params.cfg,
+			channels: {
+				...channels,
+				[params.channelId]: accounts.entry
+			}
+		},
+		changes
+	};
+}
+//#endregion
+//#region src/plugin-sdk/legacy-webhook-listener-migration.ts
+/** Preserve explicitly configured webhook listeners while moving ingress onto Gateway routes. */
+function createLegacyWebhookListenerDoctorContract(params) {
+	const portKey = params.portKey ?? "webhookPort";
+	const hostKey = params.hostKey === void 0 ? "webhookHost" : params.hostKey;
+	const source = (entry) => params.webhookKey ? asNullableRecord(entry[params.webhookKey]) : entry;
+	const hasLegacy = (value) => {
+		const entry = asNullableRecord(value);
+		const listener = entry && source(entry);
+		return Boolean(listener && (Object.hasOwn(listener, portKey) || hostKey && Object.hasOwn(listener, hostKey)));
+	};
+	const prefix = `channels.${params.channelKey}`;
+	return {
+		legacyConfigRules: [{
+			path: ["channels", params.channelKey],
+			message: `${prefix} webhook listeners moved to Gateway routes. Run "openclaw doctor --fix" to preserve explicitly configured listener settings as legacyWebhook.`,
+			match: (value) => {
+				const accounts = asNullableRecord(asNullableRecord(value)?.accounts);
+				return hasLegacy(value) || Object.values(accounts ?? {}).some(hasLegacy);
+			}
+		}],
+		normalizeCompatibilityConfig: ({ cfg }) => {
+			const root = asNullableRecord(asNullableRecord(cfg.channels)?.[params.channelKey]);
+			const inherited = root && source(root);
+			const canonicalRoot = asNullableRecord(root?.legacyWebhook);
+			return normalizeChannelConfigEntries({
+				cfg,
+				channelId: params.channelKey,
+				normalizeEntry: ({ entry, accountId, pathPrefix, changes }) => {
+					const listener = source(entry);
+					if (!listener || !hasLegacy(entry)) return {
+						entry,
+						changed: false
+					};
+					const next = { ...entry };
+					const port = Object.hasOwn(listener, portKey) ? listener[portKey] : (accountId ? canonicalRoot?.port ?? inherited?.[portKey] : void 0) ?? params.defaultPort;
+					const inheritedHost = accountId ? canonicalRoot ? canonicalRoot.host : (hostKey ? inherited?.[hostKey] : void 0) ?? params.defaultHost : params.defaultHost;
+					const host = hostKey ? listener[hostKey] ?? inheritedHost : inheritedHost;
+					const legacyPath = [pathPrefix, params.webhookKey].filter(Boolean).join(".");
+					if (Object.hasOwn(entry, "legacyWebhook")) changes.push(`Removed ${legacyPath} legacy listener keys; ${pathPrefix}.legacyWebhook is already configured.`);
+					else if (accountId && root?.legacyWebhook === false) changes.push(`Removed ${legacyPath} legacy listener keys; ${prefix}.legacyWebhook: false keeps this account's inherited listener disabled.`);
+					else {
+						next.legacyWebhook = {
+							port,
+							...host !== void 0 ? { host } : {}
+						};
+						changes.push(`Moved ${legacyPath} listener settings to ${pathPrefix}.legacyWebhook. Point the external callback or reverse proxy at the Gateway port and webhook path, verify delivery, then set legacyWebhook: false to disable legacy forwarding.`);
+					}
+					const updated = params.webhookKey ? { ...listener } : next;
+					delete updated[portKey];
+					if (hostKey) delete updated[hostKey];
+					if (params.webhookKey) {
+						if (Object.keys(updated).length) next[params.webhookKey] = updated;
+						else delete next[params.webhookKey];
+					}
+					return {
+						entry: next,
+						changed: true
+					};
+				}
+			});
+		}
+	};
+}
+//#endregion
+//#region \0openclaw:bundled-sdk:openclaw/plugin-sdk/runtime-doctor-migrations
+var runtime_doctor_migrations_exports = /* @__PURE__ */ __exportAll({ createLegacyWebhookListenerDoctorContract: () => createLegacyWebhookListenerDoctorContract });
+import * as import_openclaw_plugin_sdk_runtime_doctor_migrations from "openclaw/plugin-sdk/runtime-doctor-migrations";
+__reExport(runtime_doctor_migrations_exports, import_openclaw_plugin_sdk_runtime_doctor_migrations);
+//#endregion
+//#region extensions/acpx/src/state.ts
+const ACPX_PROCESS_LEASE_NAMESPACE = "process-leases";
+const ACPX_PROCESS_LEASE_MAX_ENTRIES = 4096;
+const ACPX_LEGACY_PROCESS_LEASE_FILE = "process-leases.json";
+const ACPX_GATEWAY_INSTANCE_NAMESPACE = "gateway-instance";
+const ACPX_GATEWAY_INSTANCE_KEY = "current";
+const ACPX_LEGACY_GATEWAY_INSTANCE_FILE = "gateway-instance-id";
+function normalizeAcpxGatewayInstanceRecord(value) {
+	const record = asOptionalObjectRecord(value);
+	const instanceId = normalizeOptionalString(record?.instanceId);
+	if (!instanceId) return;
+	return {
+		instanceId,
+		createdAt: Math.trunc(asFiniteNumber(record?.createdAt) ?? 0)
+	};
+}
+//#endregion
+//#region extensions/acpx/src/process-lease.ts
+const OPENCLAW_ACPX_LEASE_ID_ARG = "--openclaw-acpx-lease-id";
+const OPENCLAW_GATEWAY_INSTANCE_ID_ARG = "--openclaw-gateway-instance-id";
+/** Synthetic session identity for generated-wrapper health probes. */
+const ACPX_PROBE_LEASE_SESSION_KEY = "openclaw:acpx:probe";
+function readAcpxProcessLeaseIdentity(command) {
+	const parts = typeof command === "string" ? Array.from(command.matchAll(/(?:^|\s)(--openclaw-(?:acpx-lease-id|gateway-instance-id))\s+(?:"([^"]*)"|'([^']*)'|(\S+))(?=\s|$)/g)).flatMap((match) => [match[1], match[2] ?? match[3] ?? match[4]]) : command ?? [];
+	const leaseIndex = parts.lastIndexOf(OPENCLAW_ACPX_LEASE_ID_ARG);
+	const gatewayIndex = parts.lastIndexOf(OPENCLAW_GATEWAY_INSTANCE_ID_ARG);
+	const leaseId = leaseIndex >= 0 ? parts[leaseIndex + 1]?.trim() : "";
+	const gatewayInstanceId = gatewayIndex >= 0 ? parts[gatewayIndex + 1]?.trim() : "";
+	if (!leaseId || !gatewayInstanceId) return;
+	return {
+		leaseId,
+		gatewayInstanceId
+	};
+}
+function normalizeAcpxProcessLease(value) {
+	const record = asOptionalObjectRecord(value);
+	if (!record || typeof record.leaseId !== "string" || typeof record.gatewayInstanceId !== "string" || typeof record.sessionKey !== "string" || typeof record.wrapperRoot !== "string" || typeof record.wrapperPath !== "string" || typeof record.rootPid !== "number" || typeof record.commandHash !== "string" || typeof record.startedAt !== "number" || ![
+		"open",
+		"closing",
+		"closed",
+		"lost"
+	].includes(String(record.state))) return;
+	return {
+		leaseId: record.leaseId,
+		gatewayInstanceId: record.gatewayInstanceId,
+		sessionKey: record.sessionKey,
+		wrapperRoot: record.wrapperRoot,
+		wrapperPath: record.wrapperPath,
+		rootPid: record.rootPid,
+		...typeof record.processGroupId === "number" ? { processGroupId: record.processGroupId } : {},
+		commandHash: record.commandHash,
+		startedAt: record.startedAt,
+		state: record.state
+	};
+}
+function normalizeAcpxProcessLeaseFile(value) {
+	const root = asRecord(value);
+	return {
+		version: 1,
+		leases: Array.isArray(root.leases) ? root.leases.map(normalizeAcpxProcessLease).filter((lease) => Boolean(lease)) : []
+	};
+}
+function openAcpxProcessLeaseStateStore(openKeyedStore) {
+	return openKeyedStore({
+		namespace: ACPX_PROCESS_LEASE_NAMESPACE,
+		maxEntries: ACPX_PROCESS_LEASE_MAX_ENTRIES,
+		overflowPolicy: "reject-new"
+	});
+}
+function createAcpxProcessLeaseStore(params) {
+	let updateQueue = Promise.resolve();
+	async function update(mutator) {
+		const run = updateQueue.then(mutator);
+		updateQueue = run.catch(() => {});
+		await run;
+	}
+	async function readCurrent() {
+		await updateQueue;
+		return (await params.store.entries()).map((entry) => normalizeAcpxProcessLease(entry.value)).filter((lease) => Boolean(lease));
+	}
+	return {
+		async load(leaseId) {
+			await updateQueue;
+			return normalizeAcpxProcessLease(await params.store.lookup(leaseId));
+		},
+		async listOpen(gatewayInstanceId) {
+			return (await readCurrent()).filter((lease) => (lease.state === "open" || lease.state === "closing") && (!gatewayInstanceId || lease.gatewayInstanceId === gatewayInstanceId));
+		},
+		async save(lease) {
+			await update(async () => {
+				await params.store.register(lease.leaseId, lease);
+			});
+		},
+		async markState(leaseId, state) {
+			await update(async () => {
+				if (state === "closed" || state === "lost") {
+					await params.store.delete(leaseId);
+					return;
+				}
+				const lease = normalizeAcpxProcessLease(await params.store.lookup(leaseId));
+				if (lease) await params.store.register(leaseId, {
+					...lease,
+					state
+				});
+			});
+		}
+	};
+}
+/** Hash a wrapper command so process leases can detect command drift. */
+function hashAcpxProcessCommand(command) {
+	return createHash("sha256").update(renderAgentCommand(command)).digest("hex");
+}
+/** Append portable wrapper arguments without changing the executable or argument bytes. */
+function withAcpxLeaseArgs(params) {
+	return [
+		...splitCommandParts(params.command),
+		OPENCLAW_ACPX_LEASE_ID_ARG,
+		params.leaseId,
+		OPENCLAW_GATEWAY_INSTANCE_ID_ARG,
+		params.gatewayInstanceId
+	];
+}
+//#endregion
+export { __exportAll as _, hashAcpxProcessCommand as a, openAcpxProcessLeaseStateStore as c, ACPX_GATEWAY_INSTANCE_KEY as d, ACPX_GATEWAY_INSTANCE_NAMESPACE as f, runtime_doctor_migrations_exports as g, normalizeAcpxGatewayInstanceRecord as h, createAcpxProcessLeaseStore as i, readAcpxProcessLeaseIdentity as l, ACPX_LEGACY_PROCESS_LEASE_FILE as m, OPENCLAW_ACPX_LEASE_ID_ARG as n, normalizeAcpxProcessLease as o, ACPX_LEGACY_GATEWAY_INSTANCE_FILE as p, OPENCLAW_GATEWAY_INSTANCE_ID_ARG as r, normalizeAcpxProcessLeaseFile as s, ACPX_PROBE_LEASE_SESSION_KEY as t, withAcpxLeaseArgs as u };