openclaw-multi-auto 1.0.2 → 1.0.3

package/dist/plugin-sdk/{skills-QudILG6e.js → skills-Cw_vXEJb.js}

@@ -1,11 +1,11 @@
-import { E as resolveOpenClawPackageRootSync, H as normalizeSkillFilter, z as isPathInside } from "./run-with-concurrency-BR1DXa8T.js";
-import { $n as parseBooleanValue, J as resolveMemorySlotDecision, K as normalizePluginsConfig, U as LEGACY_MANIFEST_KEYS, W as MANIFEST_KEY, Xn as isDangerousHostEnvVarName, kn as isPathInsideWithRealpath, nr as normalizeResolvedSecretInputString, q as resolveEffectiveEnableState, z as loadPluginManifestRegistry } from "./config-CHQrpx-Q.js";
-import { O as createSubsystemLogger, Y as resolvePreferredOpenClawTmpDir, a as CONFIG_DIR, y as resolveUserPath } from "./logger-DHIIvMxj.js";
-import { n as assertNoPathAliasEscape } from "./path-alias-guards-C7Vm5DZ1.js";
+import { E as resolveOpenClawPackageRootSync, H as normalizeSkillFilter, z as isPathInside } from "./run-with-concurrency-C_KCHwvf.js";
+import { $n as parseBooleanValue, J as resolveMemorySlotDecision, K as normalizePluginsConfig, U as LEGACY_MANIFEST_KEYS, W as MANIFEST_KEY, Xn as isDangerousHostEnvVarName, kn as isPathInsideWithRealpath, nr as normalizeResolvedSecretInputString, q as resolveEffectiveEnableState, z as loadPluginManifestRegistry } from "./config-B1z-UxQ3.js";
+import { O as createSubsystemLogger, Y as resolvePreferredOpenClawTmpDir, a as CONFIG_DIR, y as resolveUserPath } from "./logger-CvPFVOgT.js";
+import { n as assertNoPathAliasEscape } from "./path-alias-guards-sWayacde.js";
 import path from "node:path";
 import fs from "node:fs";
 import os from "node:os";
-import JSON5 from "json5";
+import json5 from "json5";
 import { URL as URL$1, fileURLToPath } from "node:url";
 import { formatSkillsForPrompt, loadSkillsFromDir } from "@mariozechner/pi-coding-agent";
 import YAML from "yaml";
@@ -285,7 +285,7 @@ function resolveOpenClawManifestBlock(params) {
 	const raw = getFrontmatterString(params.frontmatter, params.key ?? "metadata");
 	if (!raw) return;
 	try {
-		const parsed = JSON5.parse(raw);
+		const parsed = json5.parse(raw);
 		if (!parsed || typeof parsed !== "object") return;
 		const manifestKeys = [MANIFEST_KEY, ...LEGACY_MANIFEST_KEYS];
 		for (const key of manifestKeys) {

package/dist/plugin-sdk/slash-commands.runtime-CxliuGaP.js

@@ -0,0 +1,13 @@
+import "./run-with-concurrency-Bt_ks0Qa.js";
+import "./accounts-DP1-L-QS.js";
+import "./paths-MKyEVmEb.js";
+import "./github-copilot-token-D5fdS6xD.js";
+import "./config-BkEnz2Po.js";
+import "./logger-CZY9KIoY.js";
+import "./thinking-Bo2eosVa.js";
+import "./plugins-DeBZB9l_.js";
+import "./accounts-CJWOBzwB.js";
+import "./accounts-DZhWlEg3.js";
+import { f as resolveCommandArgMenu, n as findCommandByNativeName, s as listNativeCommandSpecsForConfig, t as buildCommandTextFromArgs, u as parseCommandArgs } from "./commands-registry-t7cXBTfN.js";
+
+export { buildCommandTextFromArgs, findCommandByNativeName, listNativeCommandSpecsForConfig, parseCommandArgs, resolveCommandArgMenu };

package/dist/plugin-sdk/slash-commands.runtime-D67JLweo.js

@@ -0,0 +1,13 @@
+import "./run-with-concurrency-C_KCHwvf.js";
+import "./config-B1z-UxQ3.js";
+import "./logger-CvPFVOgT.js";
+import "./paths-0d8fBoC4.js";
+import "./accounts-CNCCkdEF.js";
+import "./plugins-C4USiH29.js";
+import "./thinking-DOnsR_A8.js";
+import "./accounts-BslAlVYS.js";
+import "./accounts-C3m65--E.js";
+import "./github-copilot-token-CKKBybuX.js";
+import { f as resolveCommandArgMenu, n as findCommandByNativeName, s as listNativeCommandSpecsForConfig, t as buildCommandTextFromArgs, u as parseCommandArgs } from "./commands-registry-CdYjoI0i.js";
+
+export { buildCommandTextFromArgs, findCommandByNativeName, listNativeCommandSpecsForConfig, parseCommandArgs, resolveCommandArgMenu };

package/dist/plugin-sdk/slash-dispatch.runtime-DFaeYlJQ.js

@@ -0,0 +1,52 @@
+import "./run-with-concurrency-Bt_ks0Qa.js";
+import "./accounts-DP1-L-QS.js";
+import { N as finalizeInboundContext, X as createReplyPrefixOptions, a as deliverSlackSlashReplies, m as dispatchReplyWithDispatcher, n as recordInboundSessionMetaSafe, v as resolveAgentRoute } from "./reply-DAo_Jt8K.js";
+import "./paths-MKyEVmEb.js";
+import "./github-copilot-token-D5fdS6xD.js";
+import "./config-BkEnz2Po.js";
+import "./logger-CZY9KIoY.js";
+import "./thinking-Bo2eosVa.js";
+import "./image-ops-BSiMpAw4.js";
+import { rn as resolveConversationLabel } from "./pi-embedded-helpers-1R1gu7eX.js";
+import "./plugins-DeBZB9l_.js";
+import "./accounts-CJWOBzwB.js";
+import "./accounts-DZhWlEg3.js";
+import "./send-DTB24bEF.js";
+import "./paths-vTM3Lh3X.js";
+import "./fetch-Bv4TQOMH.js";
+import "./redact-DjVX-1N3.js";
+import "./errors-DaiAM-yU.js";
+import "./channel-activity-F3d0yUwy.js";
+import "./path-alias-guards-DBjLbIX_.js";
+import "./fs-safe-B8y811FR.js";
+import "./ssrf-cFtplYtS.js";
+import "./fetch-guard-DETCcJzQ.js";
+import "./local-roots-BUP4YBmR.js";
+import { d as resolveChunkMode, i as resolveMarkdownTableMode } from "./ir-DQ7_HbvK.js";
+import "./render-HmipMDlP.js";
+import "./tables-C47P4GTN.js";
+import "./send-DfHadjZ_.js";
+import "./send-CQpMudwO.js";
+import "./tool-images-Gk_-0y2N.js";
+import "./target-errors-Blia4S69.js";
+import "./send-DQHLzVyO.js";
+import "./audio-transcription-runner-DkoPNPYt.js";
+import "./tokens-DgNRBwIg.js";
+import "./skill-commands-CkGeFUMl.js";
+import "./skills-CBkHBYPq.js";
+import "./chrome-BXoCyCkY.js";
+import "./deliver-B6AG_l67.js";
+import "./diagnostic-CsP-lEkI.js";
+import "./store-5nyxY3WU.js";
+import "./commands-registry-t7cXBTfN.js";
+import "./image-DjTEkYZE.js";
+import "./api-key-rotation-BRE4X2tf.js";
+import "./proxy-fetch-ChxOhWF4.js";
+import "./pi-model-discovery-v-XPUOOf.js";
+import "./send-XXlW2iny.js";
+import "./outbound-attachment-Dy6fyf6H.js";
+import "./proxy-BKdNrmWL.js";
+import "./manager-I6KbPihW.js";
+import "./query-expansion-CeyKUeDW.js";
+
+export { createReplyPrefixOptions, deliverSlackSlashReplies, dispatchReplyWithDispatcher, finalizeInboundContext, recordInboundSessionMetaSafe, resolveAgentRoute, resolveChunkMode, resolveConversationLabel, resolveMarkdownTableMode };

package/dist/plugin-sdk/slash-dispatch.runtime-DvcpvCJ0.js

@@ -0,0 +1,52 @@
+import "./run-with-concurrency-C_KCHwvf.js";
+import "./config-B1z-UxQ3.js";
+import "./logger-CvPFVOgT.js";
+import "./paths-0d8fBoC4.js";
+import "./accounts-CNCCkdEF.js";
+import "./plugins-C4USiH29.js";
+import "./thinking-DOnsR_A8.js";
+import "./accounts-BslAlVYS.js";
+import "./send-C0w6xP2x.js";
+import "./common-oYc5vPFl.js";
+import { H as finalizeInboundContext, O as resolveAgentRoute, S as dispatchReplyWithDispatcher, o as deliverSlackSlashReplies, r as recordInboundSessionMetaSafe, u as createReplyPrefixOptions } from "./reply-CTCSeQqW.js";
+import "./image-ops-Cbzr4U9l.js";
+import { rn as resolveConversationLabel } from "./pi-embedded-helpers-DIxXkGJf.js";
+import "./accounts-C3m65--E.js";
+import "./send-CFf-1V89.js";
+import "./github-copilot-token-CKKBybuX.js";
+import "./paths-Dpg3qxcl.js";
+import "./send-qPyNGSe4.js";
+import "./tokens-BDr0Z9o3.js";
+import "./audio-transcription-runner-DnxvOS1-.js";
+import "./image-B2mQW9Rb.js";
+import "./chrome-CjNTuJML.js";
+import "./skills-Cw_vXEJb.js";
+import "./path-alias-guards-sWayacde.js";
+import "./redact-Bvxt1T_Q.js";
+import "./errors-B3cHyZZA.js";
+import "./fs-safe-BaKqI3G4.js";
+import "./proxy-env-ET-rp8eg.js";
+import "./store-CMHj6IIw.js";
+import "./tool-images-eEfOVkzf.js";
+import "./fetch-guard-Dcgod0tg.js";
+import "./api-key-rotation-BXnNsojA.js";
+import "./local-roots-CIPRxA-4.js";
+import "./proxy-fetch-uDXGKG3Z.js";
+import "./deliver-D5_6T567.js";
+import "./commands-registry-CdYjoI0i.js";
+import "./skill-commands-DZqhtmiv.js";
+import "./fetch-O45GieZo.js";
+import "./diagnostic-Bxxu0ig-.js";
+import "./pi-model-discovery-DM_2uFtj.js";
+import { m as resolveChunkMode, s as resolveMarkdownTableMode } from "./ir-ZEmrTr4J.js";
+import "./render-95l30zcf.js";
+import "./send-BZ6nYFZr.js";
+import "./outbound-attachment-BzVhxRRw.js";
+import "./send-CY-Qfwia.js";
+import "./channel-activity-WJYxcJ3S.js";
+import "./tables-CSqrHsKL.js";
+import "./proxy-BOZmkV9K.js";
+import "./manager-BEoYPn7R.js";
+import "./query-expansion-C6uS-7lj.js";
+
+export { createReplyPrefixOptions, deliverSlackSlashReplies, dispatchReplyWithDispatcher, finalizeInboundContext, recordInboundSessionMetaSafe, resolveAgentRoute, resolveChunkMode, resolveConversationLabel, resolveMarkdownTableMode };

package/dist/plugin-sdk/slash-skill-commands.runtime-0M0OLCxq.js

@@ -0,0 +1,16 @@
+import "./run-with-concurrency-Bt_ks0Qa.js";
+import "./accounts-DP1-L-QS.js";
+import "./paths-MKyEVmEb.js";
+import "./github-copilot-token-D5fdS6xD.js";
+import "./config-BkEnz2Po.js";
+import "./logger-CZY9KIoY.js";
+import "./thinking-Bo2eosVa.js";
+import "./plugins-DeBZB9l_.js";
+import "./accounts-CJWOBzwB.js";
+import "./accounts-DZhWlEg3.js";
+import "./path-alias-guards-DBjLbIX_.js";
+import { n as listSkillCommandsForAgents } from "./skill-commands-CkGeFUMl.js";
+import "./skills-CBkHBYPq.js";
+import "./commands-registry-t7cXBTfN.js";
+
+export { listSkillCommandsForAgents };

package/dist/plugin-sdk/slash-skill-commands.runtime-BM1x3azR.js

@@ -0,0 +1,16 @@
+import "./run-with-concurrency-C_KCHwvf.js";
+import "./config-B1z-UxQ3.js";
+import "./logger-CvPFVOgT.js";
+import "./paths-0d8fBoC4.js";
+import "./accounts-CNCCkdEF.js";
+import "./plugins-C4USiH29.js";
+import "./thinking-DOnsR_A8.js";
+import "./accounts-BslAlVYS.js";
+import "./accounts-C3m65--E.js";
+import "./github-copilot-token-CKKBybuX.js";
+import "./skills-Cw_vXEJb.js";
+import "./path-alias-guards-sWayacde.js";
+import "./commands-registry-CdYjoI0i.js";
+import { n as listSkillCommandsForAgents } from "./skill-commands-DZqhtmiv.js";
+
+export { listSkillCommandsForAgents };

package/dist/plugin-sdk/ssrf-cFtplYtS.js

@@ -0,0 +1,202 @@
+import { $ as parseCanonicalIpAddress, G as isBlockedSpecialUseIpv4Address, J as isIpv4Address, K as isBlockedSpecialUseIpv6Address, W as extractEmbeddedIpv4FromIpv6, Y as isLegacyIpv4Literal, et as parseLooseIpAddress, q as isCanonicalDottedDecimalIPv4 } from "./config-BkEnz2Po.js";
+import { Agent } from "undici";
+import { lookup } from "node:dns";
+import { lookup as lookup$1 } from "node:dns/promises";
+
+//#region src/infra/net/proxy-env.ts
+const PROXY_ENV_KEYS = [
+	"HTTP_PROXY",
+	"HTTPS_PROXY",
+	"ALL_PROXY",
+	"http_proxy",
+	"https_proxy",
+	"all_proxy"
+];
+function hasProxyEnvConfigured(env = process.env) {
+	for (const key of PROXY_ENV_KEYS) {
+		const value = env[key];
+		if (typeof value === "string" && value.trim().length > 0) return true;
+	}
+	return false;
+}
+
+//#endregion
+//#region src/infra/net/hostname.ts
+function normalizeHostname(hostname) {
+	const normalized = hostname.trim().toLowerCase().replace(/\.$/, "");
+	if (normalized.startsWith("[") && normalized.endsWith("]")) return normalized.slice(1, -1);
+	return normalized;
+}
+
+//#endregion
+//#region src/infra/net/ssrf.ts
+var SsrFBlockedError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "SsrFBlockedError";
+	}
+};
+const BLOCKED_HOSTNAMES = new Set([
+	"localhost",
+	"localhost.localdomain",
+	"metadata.google.internal"
+]);
+function normalizeHostnameSet(values) {
+	if (!values || values.length === 0) return /* @__PURE__ */ new Set();
+	return new Set(values.map((value) => normalizeHostname(value)).filter(Boolean));
+}
+function normalizeHostnameAllowlist(values) {
+	if (!values || values.length === 0) return [];
+	return Array.from(new Set(values.map((value) => normalizeHostname(value)).filter((value) => value !== "*" && value !== "*." && value.length > 0)));
+}
+function isPrivateNetworkAllowedByPolicy(policy) {
+	return policy?.dangerouslyAllowPrivateNetwork === true || policy?.allowPrivateNetwork === true;
+}
+function resolveIpv4SpecialUseBlockOptions(policy) {
+	return { allowRfc2544BenchmarkRange: policy?.allowRfc2544BenchmarkRange === true };
+}
+function isHostnameAllowedByPattern(hostname, pattern) {
+	if (pattern.startsWith("*.")) {
+		const suffix = pattern.slice(2);
+		if (!suffix || hostname === suffix) return false;
+		return hostname.endsWith(`.${suffix}`);
+	}
+	return hostname === pattern;
+}
+function matchesHostnameAllowlist(hostname, allowlist) {
+	if (allowlist.length === 0) return true;
+	return allowlist.some((pattern) => isHostnameAllowedByPattern(hostname, pattern));
+}
+function looksLikeUnsupportedIpv4Literal(address) {
+	const parts = address.split(".");
+	if (parts.length === 0 || parts.length > 4) return false;
+	if (parts.some((part) => part.length === 0)) return true;
+	return parts.every((part) => /^[0-9]+$/.test(part) || /^0x/i.test(part));
+}
+function isPrivateIpAddress(address, policy) {
+	let normalized = address.trim().toLowerCase();
+	if (normalized.startsWith("[") && normalized.endsWith("]")) normalized = normalized.slice(1, -1);
+	if (!normalized) return false;
+	const blockOptions = resolveIpv4SpecialUseBlockOptions(policy);
+	const strictIp = parseCanonicalIpAddress(normalized);
+	if (strictIp) {
+		if (isIpv4Address(strictIp)) return isBlockedSpecialUseIpv4Address(strictIp, blockOptions);
+		if (isBlockedSpecialUseIpv6Address(strictIp)) return true;
+		const embeddedIpv4 = extractEmbeddedIpv4FromIpv6(strictIp);
+		if (embeddedIpv4) return isBlockedSpecialUseIpv4Address(embeddedIpv4, blockOptions);
+		return false;
+	}
+	if (normalized.includes(":") && !parseLooseIpAddress(normalized)) return true;
+	if (!isCanonicalDottedDecimalIPv4(normalized) && isLegacyIpv4Literal(normalized)) return true;
+	if (looksLikeUnsupportedIpv4Literal(normalized)) return true;
+	return false;
+}
+function isBlockedHostname(hostname) {
+	const normalized = normalizeHostname(hostname);
+	if (!normalized) return false;
+	return isBlockedHostnameNormalized(normalized);
+}
+function isBlockedHostnameNormalized(normalized) {
+	if (BLOCKED_HOSTNAMES.has(normalized)) return true;
+	return normalized.endsWith(".localhost") || normalized.endsWith(".local") || normalized.endsWith(".internal");
+}
+function isBlockedHostnameOrIp(hostname, policy) {
+	const normalized = normalizeHostname(hostname);
+	if (!normalized) return false;
+	return isBlockedHostnameNormalized(normalized) || isPrivateIpAddress(normalized, policy);
+}
+const BLOCKED_HOST_OR_IP_MESSAGE = "Blocked hostname or private/internal/special-use IP address";
+const BLOCKED_RESOLVED_IP_MESSAGE = "Blocked: resolves to private/internal/special-use IP address";
+function assertAllowedHostOrIpOrThrow(hostnameOrIp, policy) {
+	if (isBlockedHostnameOrIp(hostnameOrIp, policy)) throw new SsrFBlockedError(BLOCKED_HOST_OR_IP_MESSAGE);
+}
+function assertAllowedResolvedAddressesOrThrow(results, policy) {
+	for (const entry of results) if (isBlockedHostnameOrIp(entry.address, policy)) throw new SsrFBlockedError(BLOCKED_RESOLVED_IP_MESSAGE);
+}
+function createPinnedLookup(params) {
+	const normalizedHost = normalizeHostname(params.hostname);
+	const fallback = params.fallback ?? lookup;
+	const fallbackLookup = fallback;
+	const fallbackWithOptions = fallback;
+	const records = params.addresses.map((address) => ({
+		address,
+		family: address.includes(":") ? 6 : 4
+	}));
+	let index = 0;
+	return ((host, options, callback) => {
+		const cb = typeof options === "function" ? options : callback;
+		if (!cb) return;
+		const normalized = normalizeHostname(host);
+		if (!normalized || normalized !== normalizedHost) {
+			if (typeof options === "function" || options === void 0) return fallbackLookup(host, cb);
+			return fallbackWithOptions(host, options, cb);
+		}
+		const opts = typeof options === "object" && options !== null ? options : {};
+		const requestedFamily = typeof options === "number" ? options : typeof opts.family === "number" ? opts.family : 0;
+		const candidates = requestedFamily === 4 || requestedFamily === 6 ? records.filter((entry) => entry.family === requestedFamily) : records;
+		const usable = candidates.length > 0 ? candidates : records;
+		if (opts.all) {
+			cb(null, usable);
+			return;
+		}
+		const chosen = usable[index % usable.length];
+		index += 1;
+		cb(null, chosen.address, chosen.family);
+	});
+}
+function dedupeAndPreferIpv4(results) {
+	const seen = /* @__PURE__ */ new Set();
+	const ipv4 = [];
+	const otherFamilies = [];
+	for (const entry of results) {
+		if (seen.has(entry.address)) continue;
+		seen.add(entry.address);
+		if (entry.family === 4) {
+			ipv4.push(entry.address);
+			continue;
+		}
+		otherFamilies.push(entry.address);
+	}
+	return [...ipv4, ...otherFamilies];
+}
+async function resolvePinnedHostnameWithPolicy(hostname, params = {}) {
+	const normalized = normalizeHostname(hostname);
+	if (!normalized) throw new Error("Invalid hostname");
+	const allowPrivateNetwork = isPrivateNetworkAllowedByPolicy(params.policy);
+	const allowedHostnames = normalizeHostnameSet(params.policy?.allowedHostnames);
+	const hostnameAllowlist = normalizeHostnameAllowlist(params.policy?.hostnameAllowlist);
+	const isExplicitAllowed = allowedHostnames.has(normalized);
+	const skipPrivateNetworkChecks = allowPrivateNetwork || isExplicitAllowed;
+	if (!matchesHostnameAllowlist(normalized, hostnameAllowlist)) throw new SsrFBlockedError(`Blocked hostname (not in allowlist): ${hostname}`);
+	if (!skipPrivateNetworkChecks) assertAllowedHostOrIpOrThrow(normalized, params.policy);
+	const results = await (params.lookupFn ?? lookup$1)(normalized, { all: true });
+	if (results.length === 0) throw new Error(`Unable to resolve hostname: ${hostname}`);
+	if (!skipPrivateNetworkChecks) assertAllowedResolvedAddressesOrThrow(results, params.policy);
+	const addresses = dedupeAndPreferIpv4(results);
+	if (addresses.length === 0) throw new Error(`Unable to resolve hostname: ${hostname}`);
+	return {
+		hostname: normalized,
+		addresses,
+		lookup: createPinnedLookup({
+			hostname: normalized,
+			addresses
+		})
+	};
+}
+function createPinnedDispatcher(pinned) {
+	return new Agent({ connect: { lookup: pinned.lookup } });
+}
+async function closeDispatcher(dispatcher) {
+	if (!dispatcher) return;
+	const candidate = dispatcher;
+	try {
+		if (typeof candidate.close === "function") {
+			await candidate.close();
+			return;
+		}
+		if (typeof candidate.destroy === "function") candidate.destroy();
+	} catch {}
+}
+
+//#endregion
+export { isBlockedHostnameOrIp as a, resolvePinnedHostnameWithPolicy as c, isBlockedHostname as i, normalizeHostname as l, closeDispatcher as n, isPrivateIpAddress as o, createPinnedDispatcher as r, isPrivateNetworkAllowedByPolicy as s, SsrFBlockedError as t, hasProxyEnvConfigured as u };

package/dist/plugin-sdk/store-5nyxY3WU.js

@@ -0,0 +1,81 @@
+import { w as resolveConfigDir } from "./logger-CZY9KIoY.js";
+import { c as detectMime, l as extensionForMime } from "./image-ops-BSiMpAw4.js";
+import { createWriteStream } from "node:fs";
+import path from "node:path";
+import fs$1 from "node:fs/promises";
+import crypto from "node:crypto";
+import { pipeline } from "node:stream/promises";
+import { request } from "node:https";
+
+//#region src/media/store.ts
+const resolveMediaDir = () => path.join(resolveConfigDir(), "media");
+const MEDIA_MAX_BYTES = 5 * 1024 * 1024;
+const MAX_BYTES = MEDIA_MAX_BYTES;
+const DEFAULT_TTL_MS = 120 * 1e3;
+const MEDIA_FILE_MODE = 420;
+/**
+* Sanitize a filename for cross-platform safety.
+* Removes chars unsafe on Windows/SharePoint/all platforms.
+* Keeps: alphanumeric, dots, hyphens, underscores, Unicode letters/numbers.
+*/
+function sanitizeFilename(name) {
+	const trimmed = name.trim();
+	if (!trimmed) return "";
+	return trimmed.replace(/[^\p{L}\p{N}._-]+/gu, "_").replace(/_+/g, "_").replace(/^_|_$/g, "").slice(0, 60);
+}
+/**
+* Extract original filename from path if it matches the embedded format.
+* Pattern: {original}---{uuid}.{ext} → returns "{original}.{ext}"
+* Falls back to basename if no pattern match, or "file.bin" if empty.
+*/
+function extractOriginalFilename(filePath) {
+	const basename = path.basename(filePath);
+	if (!basename) return "file.bin";
+	const ext = path.extname(basename);
+	const match = path.basename(basename, ext).match(/^(.+)---[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/i);
+	if (match?.[1]) return `${match[1]}${ext}`;
+	return basename;
+}
+function getMediaDir() {
+	return resolveMediaDir();
+}
+async function ensureMediaDir() {
+	const mediaDir = resolveMediaDir();
+	await fs$1.mkdir(mediaDir, {
+		recursive: true,
+		mode: 448
+	});
+	return mediaDir;
+}
+async function saveMediaBuffer(buffer, contentType, subdir = "inbound", maxBytes = MAX_BYTES, originalFilename) {
+	if (buffer.byteLength > maxBytes) throw new Error(`Media exceeds ${(maxBytes / (1024 * 1024)).toFixed(0)}MB limit`);
+	const dir = path.join(resolveMediaDir(), subdir);
+	await fs$1.mkdir(dir, {
+		recursive: true,
+		mode: 448
+	});
+	const uuid = crypto.randomUUID();
+	const headerExt = extensionForMime(contentType?.split(";")[0]?.trim() ?? void 0);
+	const mime = await detectMime({
+		buffer,
+		headerMime: contentType
+	});
+	const ext = headerExt ?? extensionForMime(mime) ?? "";
+	let id;
+	if (originalFilename) {
+		const base = path.parse(originalFilename).name;
+		const sanitized = sanitizeFilename(base);
+		id = sanitized ? `${sanitized}---${uuid}${ext}` : `${uuid}${ext}`;
+	} else id = ext ? `${uuid}${ext}` : uuid;
+	const dest = path.join(dir, id);
+	await fs$1.writeFile(dest, buffer, { mode: MEDIA_FILE_MODE });
+	return {
+		id,
+		path: dest,
+		size: buffer.byteLength,
+		contentType: mime
+	};
+}
+
+//#endregion
+export { saveMediaBuffer as a, getMediaDir as i, ensureMediaDir as n, extractOriginalFilename as r, MEDIA_MAX_BYTES as t };

package/dist/plugin-sdk/{store-BbDQw3g6.js → store-CMHj6IIw.js}

@@ -1,5 +1,5 @@
-import { _ as resolveConfigDir } from "./logger-DHIIvMxj.js";
-import { c as detectMime, l as extensionForMime } from "./image-ops-BnZKcbd6.js";
+import { _ as resolveConfigDir } from "./logger-CvPFVOgT.js";
+import { c as detectMime, l as extensionForMime } from "./image-ops-Cbzr4U9l.js";
 import path from "node:path";
 import fs$1 from "node:fs/promises";
 import crypto from "node:crypto";

package/dist/plugin-sdk/subagent-registry-runtime-1lbDyRzz.js

@@ -0,0 +1,52 @@
+import "./run-with-concurrency-C_KCHwvf.js";
+import "./config-B1z-UxQ3.js";
+import "./logger-CvPFVOgT.js";
+import "./paths-0d8fBoC4.js";
+import "./accounts-CNCCkdEF.js";
+import "./plugins-C4USiH29.js";
+import "./thinking-DOnsR_A8.js";
+import "./accounts-BslAlVYS.js";
+import "./send-C0w6xP2x.js";
+import "./common-oYc5vPFl.js";
+import { F as resolveRequesterForChildSession, M as countPendingDescendantRuns, N as countPendingDescendantRunsExcludingRun, P as isSubagentSessionRunActive, j as countActiveDescendantRuns } from "./reply-CTCSeQqW.js";
+import "./image-ops-Cbzr4U9l.js";
+import "./pi-embedded-helpers-DIxXkGJf.js";
+import "./accounts-C3m65--E.js";
+import "./send-CFf-1V89.js";
+import "./github-copilot-token-CKKBybuX.js";
+import "./paths-Dpg3qxcl.js";
+import "./send-qPyNGSe4.js";
+import "./tokens-BDr0Z9o3.js";
+import "./audio-transcription-runner-DnxvOS1-.js";
+import "./image-B2mQW9Rb.js";
+import "./chrome-CjNTuJML.js";
+import "./skills-Cw_vXEJb.js";
+import "./path-alias-guards-sWayacde.js";
+import "./redact-Bvxt1T_Q.js";
+import "./errors-B3cHyZZA.js";
+import "./fs-safe-BaKqI3G4.js";
+import "./proxy-env-ET-rp8eg.js";
+import "./store-CMHj6IIw.js";
+import "./tool-images-eEfOVkzf.js";
+import "./fetch-guard-Dcgod0tg.js";
+import "./api-key-rotation-BXnNsojA.js";
+import "./local-roots-CIPRxA-4.js";
+import "./proxy-fetch-uDXGKG3Z.js";
+import "./deliver-D5_6T567.js";
+import "./commands-registry-CdYjoI0i.js";
+import "./skill-commands-DZqhtmiv.js";
+import "./fetch-O45GieZo.js";
+import "./diagnostic-Bxxu0ig-.js";
+import "./pi-model-discovery-DM_2uFtj.js";
+import "./ir-ZEmrTr4J.js";
+import "./render-95l30zcf.js";
+import "./send-BZ6nYFZr.js";
+import "./outbound-attachment-BzVhxRRw.js";
+import "./send-CY-Qfwia.js";
+import "./channel-activity-WJYxcJ3S.js";
+import "./tables-CSqrHsKL.js";
+import "./proxy-BOZmkV9K.js";
+import "./manager-BEoYPn7R.js";
+import "./query-expansion-C6uS-7lj.js";
+
+export { countActiveDescendantRuns, countPendingDescendantRuns, countPendingDescendantRunsExcludingRun, isSubagentSessionRunActive, resolveRequesterForChildSession };

package/dist/plugin-sdk/subagent-registry-runtime-DCtmDwna.js

@@ -0,0 +1,52 @@
+import "./run-with-concurrency-Bt_ks0Qa.js";
+import "./accounts-DP1-L-QS.js";
+import { C as countPendingDescendantRunsExcludingRun, S as countPendingDescendantRuns, T as resolveRequesterForChildSession, w as isSubagentSessionRunActive, x as countActiveDescendantRuns } from "./reply-DAo_Jt8K.js";
+import "./paths-MKyEVmEb.js";
+import "./github-copilot-token-D5fdS6xD.js";
+import "./config-BkEnz2Po.js";
+import "./logger-CZY9KIoY.js";
+import "./thinking-Bo2eosVa.js";
+import "./image-ops-BSiMpAw4.js";
+import "./pi-embedded-helpers-1R1gu7eX.js";
+import "./plugins-DeBZB9l_.js";
+import "./accounts-CJWOBzwB.js";
+import "./accounts-DZhWlEg3.js";
+import "./send-DTB24bEF.js";
+import "./paths-vTM3Lh3X.js";
+import "./fetch-Bv4TQOMH.js";
+import "./redact-DjVX-1N3.js";
+import "./errors-DaiAM-yU.js";
+import "./channel-activity-F3d0yUwy.js";
+import "./path-alias-guards-DBjLbIX_.js";
+import "./fs-safe-B8y811FR.js";
+import "./ssrf-cFtplYtS.js";
+import "./fetch-guard-DETCcJzQ.js";
+import "./local-roots-BUP4YBmR.js";
+import "./ir-DQ7_HbvK.js";
+import "./render-HmipMDlP.js";
+import "./tables-C47P4GTN.js";
+import "./send-DfHadjZ_.js";
+import "./send-CQpMudwO.js";
+import "./tool-images-Gk_-0y2N.js";
+import "./target-errors-Blia4S69.js";
+import "./send-DQHLzVyO.js";
+import "./audio-transcription-runner-DkoPNPYt.js";
+import "./tokens-DgNRBwIg.js";
+import "./skill-commands-CkGeFUMl.js";
+import "./skills-CBkHBYPq.js";
+import "./chrome-BXoCyCkY.js";
+import "./deliver-B6AG_l67.js";
+import "./diagnostic-CsP-lEkI.js";
+import "./store-5nyxY3WU.js";
+import "./commands-registry-t7cXBTfN.js";
+import "./image-DjTEkYZE.js";
+import "./api-key-rotation-BRE4X2tf.js";
+import "./proxy-fetch-ChxOhWF4.js";
+import "./pi-model-discovery-v-XPUOOf.js";
+import "./send-XXlW2iny.js";
+import "./outbound-attachment-Dy6fyf6H.js";
+import "./proxy-BKdNrmWL.js";
+import "./manager-I6KbPihW.js";
+import "./query-expansion-CeyKUeDW.js";
+
+export { countActiveDescendantRuns, countPendingDescendantRuns, countPendingDescendantRunsExcludingRun, isSubagentSessionRunActive, resolveRequesterForChildSession };

package/dist/plugin-sdk/tables-C47P4GTN.js

@@ -0,0 +1,55 @@
+import { r as markdownToIRWithMeta } from "./ir-DQ7_HbvK.js";
+import { t as renderMarkdownWithMarkers } from "./render-HmipMDlP.js";
+
+//#region src/markdown/tables.ts
+const MARKDOWN_STYLE_MARKERS = {
+	bold: {
+		open: "**",
+		close: "**"
+	},
+	italic: {
+		open: "_",
+		close: "_"
+	},
+	strikethrough: {
+		open: "~~",
+		close: "~~"
+	},
+	code: {
+		open: "`",
+		close: "`"
+	},
+	code_block: {
+		open: "```\n",
+		close: "```"
+	}
+};
+function convertMarkdownTables(markdown, mode) {
+	if (!markdown || mode === "off") return markdown;
+	const { ir, hasTables } = markdownToIRWithMeta(markdown, {
+		linkify: false,
+		autolink: false,
+		headingStyle: "none",
+		blockquotePrefix: "",
+		tableMode: mode
+	});
+	if (!hasTables) return markdown;
+	return renderMarkdownWithMarkers(ir, {
+		styleMarkers: MARKDOWN_STYLE_MARKERS,
+		escapeText: (text) => text,
+		buildLink: (link, text) => {
+			const href = link.href.trim();
+			if (!href) return null;
+			if (!text.slice(link.start, link.end)) return null;
+			return {
+				start: link.start,
+				end: link.end,
+				open: "[",
+				close: `](${href})`
+			};
+		}
+	});
+}
+
+//#endregion
+export { convertMarkdownTables as t };

package/dist/plugin-sdk/{tables-BhvloMKN.js → tables-CSqrHsKL.js}

@@ -1,4 +1,4 @@
-import { r as markdownToIRWithMeta } from "./ir-Z4hX67TJ.js";
+import { r as markdownToIRWithMeta } from "./ir-ZEmrTr4J.js";
 import { t as renderMarkdownWithMarkers } from "./render-95l30zcf.js";
 
 //#region src/markdown/tables.ts

package/dist/{target-errors-mnlwhAjP.js → plugin-sdk/target-errors-Blia4S69.js}

@@ -1,5 +1,5 @@
-import { b as detectMime } from "./image-ops-BuUnEOE0.js";
-import { r as sanitizeToolResultImages } from "./tool-images-RZdHiZcG.js";
+import { c as detectMime } from "./image-ops-BSiMpAw4.js";
+import { r as sanitizeToolResultImages } from "./tool-images-Gk_-0y2N.js";
 import fs from "node:fs/promises";
 
 //#region src/agents/tools/common.ts