@openclaw/acpx 2026.9.1-beta.1 → 2026.9.2

package/dist/config-v8M2tNu6.js

@@ -0,0 +1,185 @@
+import { t as AcpxPluginConfigSchema } from "./config-schema-DN_uAi4R.js";
+import { createRequire } from "node:module";
+import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { formatPluginConfigIssue } from "openclaw/plugin-sdk/extension-shared";
+//#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 requireFromHere = createRequire(import.meta.url);
+function isAcpxPluginRoot(dir) {
+	return fs.existsSync(path.join(dir, "openclaw.plugin.json")) && fs.existsSync(path.join(dir, "package.json"));
+}
+function resolveNearestAcpxPluginRoot(moduleUrl) {
+	let cursor = path.dirname(fileURLToPath(moduleUrl));
+	for (let i = 0; i < 3; i += 1) {
+		if (isAcpxPluginRoot(cursor)) return cursor;
+		const parent = path.dirname(cursor);
+		if (parent === cursor) break;
+		cursor = parent;
+	}
+	return path.resolve(path.dirname(fileURLToPath(moduleUrl)), "..");
+}
+function resolveWorkspaceAcpxPluginRoot(currentRoot) {
+	if (path.basename(currentRoot) !== "acpx" || path.basename(path.dirname(currentRoot)) !== "extensions" || path.basename(path.dirname(path.dirname(currentRoot))) !== "dist") return null;
+	const workspaceRoot = path.resolve(currentRoot, "..", "..", "..", "extensions", "acpx");
+	return isAcpxPluginRoot(workspaceRoot) ? workspaceRoot : null;
+}
+function resolveRepoAcpxPluginRoot(currentRoot) {
+	const workspaceRoot = path.join(currentRoot, "extensions", "acpx");
+	return isAcpxPluginRoot(workspaceRoot) ? workspaceRoot : null;
+}
+function resolveAcpxPluginRootFromOpenClawLayout(moduleUrl) {
+	let cursor = path.dirname(fileURLToPath(moduleUrl));
+	for (let i = 0; i < 5; i += 1) {
+		const candidates = [
+			path.join(cursor, "extensions", "acpx"),
+			path.join(cursor, "dist", "extensions", "acpx"),
+			path.join(cursor, "dist-runtime", "extensions", "acpx")
+		];
+		for (const candidate of candidates) if (isAcpxPluginRoot(candidate)) return candidate;
+		const parent = path.dirname(cursor);
+		if (parent === cursor) break;
+		cursor = parent;
+	}
+	return null;
+}
+/** Resolve the ACPX plugin root across source, dist, and dist-runtime layouts. */
+function resolveAcpxPluginRoot(moduleUrl = import.meta.url) {
+	const resolvedRoot = resolveNearestAcpxPluginRoot(moduleUrl);
+	return resolveWorkspaceAcpxPluginRoot(resolvedRoot) ?? resolveRepoAcpxPluginRoot(resolvedRoot) ?? resolveAcpxPluginRootFromOpenClawLayout(moduleUrl) ?? resolvedRoot;
+}
+const DEFAULT_PERMISSION_MODE = "approve-reads";
+const DEFAULT_NON_INTERACTIVE_POLICY = "fail";
+function parseAcpxPluginConfig(value) {
+	if (value === void 0) return {
+		ok: true,
+		value: void 0
+	};
+	const parsed = AcpxPluginConfigSchema.safeParse(value);
+	if (!parsed.success) return {
+		ok: false,
+		message: formatPluginConfigIssue(parsed.error.issues[0])
+	};
+	return {
+		ok: true,
+		value: parsed.data
+	};
+}
+function resolveOpenClawRoot(currentRoot) {
+	if (path.basename(currentRoot) === "acpx" && path.basename(path.dirname(currentRoot)) === "extensions") {
+		const parent = path.dirname(path.dirname(currentRoot));
+		if (path.basename(parent) === "dist") return path.dirname(parent);
+		return parent;
+	}
+	return path.resolve(currentRoot, "..");
+}
+function resolveTsxImportSpecifier() {
+	try {
+		return requireFromHere.resolve("tsx");
+	} catch {
+		return "tsx";
+	}
+}
+function shellQuoteCommandArg(arg) {
+	if (!/[\s'"\\$|&;<>{}()*?[\]~`]/.test(arg)) return arg;
+	return `'${arg.replace(/'/g, "'\"'\"'")}'`;
+}
+function resolvePluginToolsMcpServerConfig(moduleUrl = import.meta.url) {
+	const openClawRoot = resolveOpenClawRoot(resolveAcpxPluginRoot(moduleUrl));
+	const distEntry = path.join(openClawRoot, "dist", "mcp", "plugin-tools-serve.js");
+	if (fs.existsSync(distEntry)) return {
+		command: process.execPath,
+		args: [distEntry]
+	};
+	const sourceEntry = path.join(openClawRoot, "src", "mcp", "plugin-tools-serve.ts");
+	return {
+		command: process.execPath,
+		args: [
+			"--import",
+			resolveTsxImportSpecifier(),
+			sourceEntry
+		]
+	};
+}
+function resolveOpenClawToolsMcpServerConfig(moduleUrl = import.meta.url) {
+	const openClawRoot = resolveOpenClawRoot(resolveAcpxPluginRoot(moduleUrl));
+	const distEntry = path.join(openClawRoot, "dist", "mcp", "openclaw-tools-serve.js");
+	if (fs.existsSync(distEntry)) return {
+		command: process.execPath,
+		args: [distEntry]
+	};
+	const sourceEntry = path.join(openClawRoot, "src", "mcp", "openclaw-tools-serve.ts");
+	return {
+		command: process.execPath,
+		args: [
+			"--import",
+			resolveTsxImportSpecifier(),
+			sourceEntry
+		]
+	};
+}
+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] = resolvePluginToolsMcpServerConfig(params.moduleUrl);
+	if (params.openClawToolsMcpBridge) resolved[ACPX_OPENCLAW_TOOLS_MCP_SERVER_NAME] = resolveOpenClawToolsMcpServerConfig(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,
+		command: server.command,
+		args: [...server.args ?? []],
+		env: Object.entries(server.env ?? {}).map(([envName, value]) => ({
+			name: envName,
+			value
+		}))
+	}));
+}
+/** Validate and normalize raw ACPX plugin config for runtime startup. */
+function resolveAcpxPluginConfig(params) {
+	const parsed = parseAcpxPluginConfig(params.rawConfig);
+	if (!parsed.ok) throw new Error(parsed.message);
+	const normalized = parsed.value ?? {};
+	const workspaceDir = params.workspaceDir?.trim() || process.cwd();
+	const fallbackCwd = workspaceDir;
+	const cwd = path.resolve(normalized.cwd?.trim() || fallbackCwd);
+	const stateDir = path.resolve(normalized.stateDir?.trim() || path.join(workspaceDir, "state"));
+	const pluginToolsMcpBridge = normalized.pluginToolsMcpBridge === true;
+	const openClawToolsMcpBridge = normalized.openClawToolsMcpBridge === true;
+	const mcpServers = resolveConfiguredMcpServers({
+		mcpServers: normalized.mcpServers,
+		pluginToolsMcpBridge,
+		openClawToolsMcpBridge,
+		moduleUrl: params.moduleUrl
+	});
+	const agents = Object.fromEntries(Object.entries(normalized.agents ?? {}).map(([name, entry]) => {
+		const cmd = entry.command.trim();
+		const cmdArgs = entry.args ?? [];
+		const fullCommand = cmdArgs.length > 0 ? `${cmd} ${cmdArgs.map(shellQuoteCommandArg).join(" ")}` : cmd;
+		return [normalizeLowercaseStringOrEmpty(name), fullCommand];
+	}));
+	return {
+		cwd,
+		stateDir,
+		probeAgent: normalized.probeAgent,
+		permissionMode: normalized.permissionMode ?? DEFAULT_PERMISSION_MODE,
+		nonInteractivePermissions: normalized.nonInteractivePermissions ?? DEFAULT_NON_INTERACTIVE_POLICY,
+		pluginToolsMcpBridge,
+		openClawToolsMcpBridge,
+		timeoutSeconds: normalized.timeoutSeconds ?? 120,
+		mcpServers,
+		agents
+	};
+}
+//#endregion
+export { resolveAcpxPluginRoot as n, toAcpMcpServers as r, resolveAcpxPluginConfig as t };

package/dist/doctor-contract-api.js

@@ -17,14 +17,16 @@ const legacyConfigRules = RETIRED_ACPX_CONFIG_KEYS.map((key) => ({
 }));
 /** Removes retired plugin-owned config without keeping runtime compatibility keys. */
 function normalizeCompatibilityConfig({ cfg }) {
-	const pluginConfig = asObjectRecord(asObjectRecord(cfg.plugins?.entries?.acpx)?.config);
+	const entry = asObjectRecord(cfg.plugins?.entries?.acpx);
+	const pluginConfig = asObjectRecord(entry?.config);
 	const retiredKeys = RETIRED_ACPX_CONFIG_KEYS.filter((key) => Object.hasOwn(pluginConfig ?? {}, key));
 	if (!pluginConfig || retiredKeys.length === 0) return {
 		config: cfg,
 		changes: []
 	};
 	const nextConfig = structuredClone(cfg);
-	const nextPluginConfig = asObjectRecord(asObjectRecord(nextConfig.plugins?.entries?.acpx)?.config);
+	const nextEntry = asObjectRecord(nextConfig.plugins?.entries?.acpx);
+	const nextPluginConfig = asObjectRecord(nextEntry?.config);
 	if (!nextPluginConfig) return {
 		config: cfg,
 		changes: []
@@ -129,6 +131,17 @@ const stateMigrations = [{
 			warnings
 		};
 	}
+}, {
+	id: "acpx-session-owner-resources",
+	label: "ACP session owners",
+	doctorOnly: true,
+	phase: "after-session-repair",
+	async detectLegacyState(input) {
+		return (await import("./session-owner-migration-CistlQKM.js")).acpxSessionOwnerMigration.detectLegacyState(input);
+	},
+	async migrateLegacyState(input) {
+		return (await import("./session-owner-migration-CistlQKM.js")).acpxSessionOwnerMigration.migrateLegacyState(input);
+	}
 }];
 //#endregion
 export { legacyConfigRules, normalizeCompatibilityConfig, stateMigrations };

package/dist/index.js

@@ -1,4 +1,4 @@
-import { t as createAcpxRuntimeService } from "./register.runtime-Dj29TKFy.js";
+import { t as createAcpxRuntimeService } from "./register.runtime-Ba7FPMGu.js";
 import "./config-schema-DN_uAi4R.js";
 import { a as PI_SESSIONS_CAPABILITY, c as PI_SESSION_READ_COMMAND, l as PI_TERMINAL_RESUME_COMMAND, o as PI_SESSIONS_LIST_COMMAND, r as piSessionStoreAvailable, s as PI_SESSION_ID_PATTERN } from "./pi-session-paths-EMbd4Hkz.js";
 import { tryDispatchAcpReplyHook } from "openclaw/plugin-sdk/acp-runtime-backend";
@@ -8,7 +8,7 @@ import { resolveNodeHostExecutable } from "openclaw/plugin-sdk/node-host";
 import { createSessionCatalogNodeHostBindings } from "openclaw/plugin-sdk/session-catalog";
 import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/acpx/src/pi-session-catalog-plugin.ts
-const loadPiSessionCatalogModule = createLazyRuntimeModule(() => import("./pi-session-catalog-runtime-BIu-8uRZ.js"));
+const loadPiSessionCatalogModule = createLazyRuntimeModule(() => import("./pi-session-catalog-runtime-C0HodUWT.js"));
 function fullConfigCatalogEnabled(config) {
 	if (!isRecord(config) || !isRecord(config.plugins) || !isRecord(config.plugins.entries)) return true;
 	const entry = config.plugins.entries.acpx;
@@ -105,7 +105,10 @@ const plugin = {
 			pluginConfig: api.pluginConfig,
 			openKeyedStore: (options) => api.runtime.state.openKeyedStore(options)
 		}));
-		api.on("reply_dispatch", (event, ctx) => tryDispatchAcpReplyHookWithTimeout(event, ctx, replyDispatchTimeoutMs), { timeoutMs: replyDispatchTimeoutMs });
+		api.on("reply_dispatch", (event, ctx) => tryDispatchAcpReplyHookWithTimeout(event, ctx, replyDispatchTimeoutMs), {
+			timeoutMs: replyDispatchTimeoutMs,
+			eligibleDispatchKinds: ["acp"]
+		});
 	}
 };
 //#endregion

package/dist/{pi-session-catalog-runtime-BIu-8uRZ.js → pi-session-catalog-runtime-C0HodUWT.js}

@@ -8,8 +8,9 @@ import path from "node:path";
 import fs$1 from "node:fs/promises";
 import process from "node:process";
 import { resolveAcpSessionAvailability } from "openclaw/plugin-sdk/acp-runtime";
-import { resolveSessionAgentIds } from "openclaw/plugin-sdk/agent-runtime";
+import { resolveSessionAgentIdsStrict } from "openclaw/plugin-sdk/agent-scope-runtime";
 import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
+import { runTasksWithConcurrency } from "openclaw/plugin-sdk/concurrency-runtime";
 import { isPathStrictlyInside } 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. */
@@ -21,9 +22,9 @@ function parsePiSessionTimestampMs(value) {
 const MAX_DISCOVERY_FILES = 1e4;
 const SUMMARY_SCAN_BATCH_SIZE = 100;
 const MAX_SUMMARY_CACHE_ENTRIES = 256;
-const MAX_SESSION_BYTES = 32 * 1024 * 1024;
-const MAX_SUMMARY_LINE_BYTES = 1024 * 1024;
-const APPEND_PROOF_EDGE_BYTES = 64 * 1024;
+const MAX_SESSION_BYTES = 33554432;
+const MAX_SUMMARY_LINE_BYTES = 1048576;
+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;
@@ -95,38 +96,30 @@ async function realpathOrResolve(value) {
 		return path.resolve(value);
 	}
 }
-async function mapConcurrent(values, limit, mapper) {
-	const results = [];
-	results.length = values.length;
-	let nextIndex = 0;
-	const workers = Array.from({ length: Math.min(limit, values.length) }, async () => {
-		while (nextIndex < values.length) {
-			const index = nextIndex++;
-			results[index] = await mapper(values[index]);
-		}
-	});
-	await Promise.all(workers);
-	return results;
-}
 async function scanPiFileCandidates(env) {
 	const { root, files } = await discoverPiSessionFiles(env);
 	const configuredAcpRoot = piAcpSessionStoreRoot(env);
 	const acpRoot = configuredAcpRoot ? await realpathOrResolve(configuredAcpRoot) : void 0;
-	return (await mapConcurrent(files, IO_CONCURRENCY, async (file) => {
-		try {
-			const stats = await fs$1.stat(file);
-			return stats.isFile() ? {
-				file,
-				storeRoot: root,
-				identity: `${String(stats.dev)}:${String(stats.ino)}:${String(stats.birthtimeMs)}`,
-				mtimeMs: stats.mtimeMs,
-				size: stats.size,
-				resumable: acpRoot ? isPathStrictlyInside(acpRoot, file) : false
-			} : void 0;
-		} catch {
-			return;
-		}
-	})).filter((candidate) => candidate !== void 0).toSorted((left, right) => right.mtimeMs - left.mtimeMs);
+	const { results: candidates } = await runTasksWithConcurrency({
+		tasks: files.map((file) => async () => {
+			try {
+				const stats = await fs$1.stat(file);
+				return stats.isFile() ? {
+					file,
+					storeRoot: root,
+					identity: `${String(stats.dev)}:${String(stats.ino)}:${String(stats.birthtimeMs)}`,
+					mtimeMs: stats.mtimeMs,
+					size: stats.size,
+					resumable: acpRoot ? isPathStrictlyInside(acpRoot, file) : false
+				} : void 0;
+			} catch {
+				return;
+			}
+		}),
+		limit: IO_CONCURRENCY,
+		throwOnError: true
+	});
+	return candidates.filter((candidate) => candidate !== void 0).toSorted((left, right) => right.mtimeMs - left.mtimeMs);
 }
 async function piFileCandidates(env) {
 	const store = piSessionStore(env);
@@ -323,7 +316,12 @@ async function listPiSummaryPage(env, params) {
 	const matches = [];
 	const needle = params.searchTerm?.toLocaleLowerCase();
 	for (let index = 0; index < candidates.length && matches.length < target; index += SUMMARY_SCAN_BATCH_SIZE) {
-		const summaries = await mapConcurrent(candidates.slice(index, index + SUMMARY_SCAN_BATCH_SIZE), IO_CONCURRENCY, readPiSessionSummary);
+		const batch = candidates.slice(index, index + SUMMARY_SCAN_BATCH_SIZE);
+		const { results: summaries } = await runTasksWithConcurrency({
+			tasks: batch.map((candidate) => () => readPiSessionSummary(candidate)),
+			limit: IO_CONCURRENCY,
+			throwOnError: true
+		});
 		for (const summary of summaries) if (summary && summaryMatches(summary, needle)) {
 			matches.push(summary);
 			if (matches.length >= target) break;
@@ -337,7 +335,12 @@ async function listPiSummaryPage(env, params) {
 async function findPiSummary(threadId, env) {
 	const candidates = await piFileCandidates(env);
 	for (let index = 0; index < candidates.length; index += SUMMARY_SCAN_BATCH_SIZE) {
-		const match = (await mapConcurrent(candidates.slice(index, index + SUMMARY_SCAN_BATCH_SIZE), IO_CONCURRENCY, readPiSessionSummary)).find((summary) => summary?.threadId === threadId);
+		const { results: summaries } = await runTasksWithConcurrency({
+			tasks: candidates.slice(index, index + SUMMARY_SCAN_BATCH_SIZE).map((candidate) => () => readPiSessionSummary(candidate)),
+			limit: IO_CONCURRENCY,
+			throwOnError: true
+		});
+		const match = summaries.find((summary) => summary?.threadId === threadId);
 		if (match) return match;
 	}
 }
@@ -582,7 +585,7 @@ async function readLocalPiTranscriptPage(value) {
 }
 //#endregion
 //#region extensions/acpx/src/pi-session-upstream-activity.ts
-const MAX_PI_UPSTREAM_SCAN_BYTES = 1024 * 1024;
+const MAX_PI_UPSTREAM_SCAN_BYTES = 1048576;
 async function readFileRange(handle, position, length) {
 	const buffer = Buffer.alloc(length);
 	let offset = 0;
@@ -669,7 +672,8 @@ async function checkPiSessionUpstreamActivity(probe) {
 		let occurredAt;
 		for (const entry of entries) {
 			if (entry.type !== "message" || !isRecord(entry.message) || entry.message.role !== "user") continue;
-			if (!isExternalUserText(probe, textFromContent(entry.message.content))) continue;
+			const text = textFromContent(entry.message.content);
+			if (!isExternalUserText(probe, text)) continue;
 			humanTurns += 1;
 			occurredAt = Math.max(occurredAt ?? 0, parsePiSessionTimestampMs(entry.message.timestamp) ?? parsePiSessionTimestampMs(entry.timestamp) ?? stat.mtimeMs);
 		}
@@ -754,7 +758,7 @@ async function createAdoptedPiSession(params) {
 		key: sessionCatalogAdoptedSessionKey(PI_ADOPTED_SESSION_KEY_PREFIX, params.threadId),
 		agentId: params.agentId,
 		recoverMatchingInitialEntry: true,
-		...params.session.name ? { label: params.session.name } : {},
+		...params.session.name ? { displayName: params.session.name } : {},
 		...params.session.cwd ? { spawnedCwd: params.session.cwd } : {},
 		initialEntry: {
 			acpBackendId: ACPX_BACKEND_ID,
@@ -856,7 +860,7 @@ function createPiSessionCatalogRuntime(api) {
 			sessionUnavailable: "Pi session is unavailable"
 		},
 		continuation: {
-			resolveAgentId: (agentId) => resolveSessionAgentIds({
+			resolveAgentId: (agentId) => resolveSessionAgentIdsStrict({
 				config: api.config,
 				agentId
 			}).sessionAgentId,

package/dist/{register.runtime-Dj29TKFy.js → register.runtime-Ba7FPMGu.js}

@@ -24,6 +24,7 @@ function lazyStartRuntimeTurn(resolveRuntime, input) {
 /** Create an ACP runtime facade backed by an async runtime resolver. */
 function createLazyAcpRuntimeProxy(resolveRuntime) {
 	return {
+		ownerAwareSessions: 1,
 		async ensureSession(input) {
 			return await (await resolveRuntime()).ensureSession(input);
 		},
@@ -43,7 +44,7 @@ function createLazyAcpRuntimeProxy(resolveRuntime) {
 			await (await resolveRuntime()).setMode(input);
 		},
 		async setConfigOption(input) {
-			await (await resolveRuntime()).setConfigOption(input);
+			return await (await resolveRuntime()).setConfigOption(input);
 		},
 		async doctor() {
 			return await (await resolveRuntime()).doctor();
@@ -66,7 +67,7 @@ function createLazyAcpRuntimeProxy(resolveRuntime) {
 * immediately, then imports the heavier service only when a session needs it.
 */
 const ACPX_BACKEND_ID = "acpx";
-const loadServiceModule = createLazyRuntimeModule(() => import("./service-PRlUtXMf.js"));
+const loadServiceModule = createLazyRuntimeModule(() => import("./service-COMUTA5A.js").then((n) => n.t));
 function unregisterOwnedRuntime(runtime) {
 	if (runtime && getAcpRuntimeBackend(ACPX_BACKEND_ID)?.runtime === runtime) unregisterAcpRuntimeBackend(ACPX_BACKEND_ID);
 }

package/dist/register.runtime.js

@@ -1,2 +1,2 @@
-import { t as createAcpxRuntimeService } from "./register.runtime-Dj29TKFy.js";
+import { t as createAcpxRuntimeService } from "./register.runtime-Ba7FPMGu.js";
 export { createAcpxRuntimeService };

package/dist/rolldown-runtime-8H4AJuhK.js

@@ -0,0 +1,14 @@
+import "node:module";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+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;
+};
+//#endregion
+export { __exportAll as t };