openclaw-multi-auto 1.5.0 → 1.5.1

package/dist/plugin-sdk/session-6TF6MyaC.js

@@ -0,0 +1,169 @@
+import { f as readCredsJsonRaw, g as resolveWebCredsPath, h as resolveWebCredsBackupPath, m as resolveDefaultWebAuthDir, u as maybeRestoreCredsFromBackup } from "./accounts-DP1-L-QS.js";
+import { Pr as formatCliCommand, Xr as VERSION } from "./config-BkEnz2Po.js";
+import { B as success, E as resolveUserPath, F as danger, G as getChildLogger, g as ensureDir, q as toPinoLikeLogger } from "./logger-CZY9KIoY.js";
+import fs from "node:fs";
+import { randomUUID } from "node:crypto";
+import { DisconnectReason, fetchLatestBaileysVersion, makeCacheableSignalKeyStore, makeWASocket, useMultiFileAuthState } from "@whiskeysockets/baileys";
+import qrcode from "qrcode-terminal";
+
+//#region src/web/session.ts
+let credsSaveQueue = Promise.resolve();
+function enqueueSaveCreds(authDir, saveCreds, logger) {
+	credsSaveQueue = credsSaveQueue.then(() => safeSaveCreds(authDir, saveCreds, logger)).catch((err) => {
+		logger.warn({ error: String(err) }, "WhatsApp creds save queue error");
+	});
+}
+async function safeSaveCreds(authDir, saveCreds, logger) {
+	try {
+		const credsPath = resolveWebCredsPath(authDir);
+		const backupPath = resolveWebCredsBackupPath(authDir);
+		const raw = readCredsJsonRaw(credsPath);
+		if (raw) try {
+			JSON.parse(raw);
+			fs.copyFileSync(credsPath, backupPath);
+			try {
+				fs.chmodSync(backupPath, 384);
+			} catch {}
+		} catch {}
+	} catch {}
+	try {
+		await Promise.resolve(saveCreds());
+		try {
+			fs.chmodSync(resolveWebCredsPath(authDir), 384);
+		} catch {}
+	} catch (err) {
+		logger.warn({ error: String(err) }, "failed saving WhatsApp creds");
+	}
+}
+/**
+* Create a Baileys socket backed by the multi-file auth store we keep on disk.
+* Consumers can opt into QR printing for interactive login flows.
+*/
+async function createWaSocket(printQr, verbose, opts = {}) {
+	const logger = toPinoLikeLogger(getChildLogger({ module: "baileys" }, { level: verbose ? "info" : "silent" }), verbose ? "info" : "silent");
+	const authDir = resolveUserPath(opts.authDir ?? resolveDefaultWebAuthDir());
+	await ensureDir(authDir);
+	const sessionLogger = getChildLogger({ module: "web-session" });
+	maybeRestoreCredsFromBackup(authDir);
+	const { state, saveCreds } = await useMultiFileAuthState(authDir);
+	const { version } = await fetchLatestBaileysVersion();
+	const sock = makeWASocket({
+		auth: {
+			creds: state.creds,
+			keys: makeCacheableSignalKeyStore(state.keys, logger)
+		},
+		version,
+		logger,
+		printQRInTerminal: false,
+		browser: [
+			"openclaw",
+			"cli",
+			VERSION
+		],
+		syncFullHistory: false,
+		markOnlineOnConnect: false
+	});
+	sock.ev.on("creds.update", () => enqueueSaveCreds(authDir, saveCreds, sessionLogger));
+	sock.ev.on("connection.update", (update) => {
+		try {
+			const { connection, lastDisconnect, qr } = update;
+			if (qr) {
+				opts.onQr?.(qr);
+				if (printQr) {
+					console.log("Scan this QR in WhatsApp (Linked Devices):");
+					qrcode.generate(qr, { small: true });
+				}
+			}
+			if (connection === "close") {
+				if (getStatusCode(lastDisconnect?.error) === DisconnectReason.loggedOut) console.error(danger(`WhatsApp session logged out. Run: ${formatCliCommand("openclaw channels login")}`));
+			}
+			if (connection === "open" && verbose) console.log(success("WhatsApp Web connected."));
+		} catch (err) {
+			sessionLogger.error({ error: String(err) }, "connection.update handler error");
+		}
+	});
+	if (sock.ws && typeof sock.ws.on === "function") sock.ws.on("error", (err) => {
+		sessionLogger.error({ error: String(err) }, "WebSocket error");
+	});
+	return sock;
+}
+async function waitForWaConnection(sock) {
+	return new Promise((resolve, reject) => {
+		const evWithOff = sock.ev;
+		const handler = (...args) => {
+			const update = args[0] ?? {};
+			if (update.connection === "open") {
+				evWithOff.off?.("connection.update", handler);
+				resolve();
+			}
+			if (update.connection === "close") {
+				evWithOff.off?.("connection.update", handler);
+				reject(update.lastDisconnect ?? /* @__PURE__ */ new Error("Connection closed"));
+			}
+		};
+		sock.ev.on("connection.update", handler);
+	});
+}
+function getStatusCode(err) {
+	return err?.output?.statusCode ?? err?.status;
+}
+function safeStringify(value, limit = 800) {
+	try {
+		const seen = /* @__PURE__ */ new WeakSet();
+		const raw = JSON.stringify(value, (_key, v) => {
+			if (typeof v === "bigint") return v.toString();
+			if (typeof v === "function") {
+				const maybeName = v.name;
+				return `[Function ${typeof maybeName === "string" && maybeName.length > 0 ? maybeName : "anonymous"}]`;
+			}
+			if (typeof v === "object" && v) {
+				if (seen.has(v)) return "[Circular]";
+				seen.add(v);
+			}
+			return v;
+		}, 2);
+		if (!raw) return String(value);
+		return raw.length > limit ? `${raw.slice(0, limit)}…` : raw;
+	} catch {
+		return String(value);
+	}
+}
+function extractBoomDetails(err) {
+	if (!err || typeof err !== "object") return null;
+	const output = err?.output;
+	if (!output || typeof output !== "object") return null;
+	const payload = output.payload;
+	const statusCode = typeof output.statusCode === "number" ? output.statusCode : typeof payload?.statusCode === "number" ? payload.statusCode : void 0;
+	const error = typeof payload?.error === "string" ? payload.error : void 0;
+	const message = typeof payload?.message === "string" ? payload.message : void 0;
+	if (!statusCode && !error && !message) return null;
+	return {
+		statusCode,
+		error,
+		message
+	};
+}
+function formatError(err) {
+	if (err instanceof Error) return err.message;
+	if (typeof err === "string") return err;
+	if (!err || typeof err !== "object") return String(err);
+	const boom = extractBoomDetails(err) ?? extractBoomDetails(err?.error) ?? extractBoomDetails(err?.lastDisconnect?.error);
+	const status = boom?.statusCode ?? getStatusCode(err);
+	const code = err?.code;
+	const codeText = typeof code === "string" || typeof code === "number" ? String(code) : void 0;
+	const message = [
+		boom?.message,
+		typeof err?.message === "string" ? err.message : void 0,
+		typeof err?.error?.message === "string" ? err.error?.message : void 0
+	].filter((v) => Boolean(v && v.trim().length > 0))[0];
+	const pieces = [];
+	if (typeof status === "number") pieces.push(`status=${status}`);
+	if (boom?.error) pieces.push(boom.error);
+	if (message) pieces.push(message);
+	if (codeText) pieces.push(`code=${codeText}`);
+	if (pieces.length > 0) return pieces.join(" ");
+	return safeStringify(err);
+}
+
+//#endregion
+export { waitForWaConnection as i, formatError as n, getStatusCode as r, createWaSocket as t };

package/dist/plugin-sdk/{session-k256LJZT.js → session-COrvpvUQ.js}

@@ -1,6 +1,6 @@
-import { Tr as formatCliCommand, qn as VERSION } from "./config-CHQrpx-Q.js";
-import { B as success, F as danger, G as getChildLogger, K as toPinoLikeLogger, l as ensureDir, y as resolveUserPath } from "./logger-DHIIvMxj.js";
-import { f as readCredsJsonRaw, g as resolveWebCredsPath, h as resolveWebCredsBackupPath, m as resolveDefaultWebAuthDir, u as maybeRestoreCredsFromBackup } from "./accounts-C1j7HSL0.js";
+import { Tr as formatCliCommand, qn as VERSION } from "./config-B1z-UxQ3.js";
+import { B as success, F as danger, G as getChildLogger, K as toPinoLikeLogger, l as ensureDir, y as resolveUserPath } from "./logger-CvPFVOgT.js";
+import { f as readCredsJsonRaw, g as resolveWebCredsPath, h as resolveWebCredsBackupPath, m as resolveDefaultWebAuthDir, u as maybeRestoreCredsFromBackup } from "./accounts-CNCCkdEF.js";
 import fs from "node:fs";
 import { randomUUID } from "node:crypto";
 import { DisconnectReason, fetchLatestBaileysVersion, makeCacheableSignalKeyStore, makeWASocket, useMultiFileAuthState } from "@whiskeysockets/baileys";

package/dist/plugin-sdk/skill-commands-CkGeFUMl.js

@@ -0,0 +1,342 @@
+import { c as resolveAgentWorkspaceDir, r as listAgentIds, s as resolveAgentSkillsFilter } from "./run-with-concurrency-Bt_ks0Qa.js";
+import { c as resolveStateDir } from "./paths-MKyEVmEb.js";
+import { E as resolveUserPath, L as logVerbose, a as createSubsystemLogger, f as CONFIG_DIR } from "./logger-CZY9KIoY.js";
+import { t as createAsyncLock } from "./json-files-DJe5SBCd.js";
+import { o as resolvePluginSkillDirs, t as buildWorkspaceSkillCommandSpecs } from "./skills-CBkHBYPq.js";
+import { i as listChatCommands } from "./commands-registry-t7cXBTfN.js";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { randomBytes, randomUUID } from "node:crypto";
+import chokidar from "chokidar";
+
+//#region src/infra/pairing-files.ts
+function resolvePairingPaths(baseDir, subdir) {
+	const root = baseDir ?? resolveStateDir();
+	const dir = path.join(root, subdir);
+	return {
+		dir,
+		pendingPath: path.join(dir, "pending.json"),
+		pairedPath: path.join(dir, "paired.json")
+	};
+}
+function pruneExpiredPending(pendingById, nowMs, ttlMs) {
+	for (const [id, req] of Object.entries(pendingById)) if (nowMs - req.ts > ttlMs) delete pendingById[id];
+}
+
+//#endregion
+//#region src/infra/pairing-pending.ts
+async function rejectPendingPairingRequest(params) {
+	const state = await params.loadState();
+	const pending = state.pendingById[params.requestId];
+	if (!pending) return null;
+	delete state.pendingById[params.requestId];
+	await params.persistState(state);
+	return {
+		requestId: params.requestId,
+		[params.idKey]: params.getId(pending)
+	};
+}
+
+//#endregion
+//#region src/infra/pairing-token.ts
+const PAIRING_TOKEN_BYTES = 32;
+function generatePairingToken() {
+	return randomBytes(PAIRING_TOKEN_BYTES).toString("base64url");
+}
+
+//#endregion
+//#region src/agents/skills/refresh.ts
+const log$1 = createSubsystemLogger("gateway/skills");
+const listeners = /* @__PURE__ */ new Set();
+const workspaceVersions = /* @__PURE__ */ new Map();
+const watchers = /* @__PURE__ */ new Map();
+let globalVersion = 0;
+const DEFAULT_SKILLS_WATCH_IGNORED = [
+	/(^|[\\/])\.git([\\/]|$)/,
+	/(^|[\\/])node_modules([\\/]|$)/,
+	/(^|[\\/])dist([\\/]|$)/,
+	/(^|[\\/])\.venv([\\/]|$)/,
+	/(^|[\\/])venv([\\/]|$)/,
+	/(^|[\\/])__pycache__([\\/]|$)/,
+	/(^|[\\/])\.mypy_cache([\\/]|$)/,
+	/(^|[\\/])\.pytest_cache([\\/]|$)/,
+	/(^|[\\/])build([\\/]|$)/,
+	/(^|[\\/])\.cache([\\/]|$)/
+];
+function bumpVersion(current) {
+	const now = Date.now();
+	return now <= current ? current + 1 : now;
+}
+function emit(event) {
+	for (const listener of listeners) try {
+		listener(event);
+	} catch (err) {
+		log$1.warn(`skills change listener failed: ${String(err)}`);
+	}
+}
+function resolveWatchPaths(workspaceDir, config) {
+	const paths = [];
+	if (workspaceDir.trim()) {
+		paths.push(path.join(workspaceDir, "skills"));
+		paths.push(path.join(workspaceDir, ".agents", "skills"));
+	}
+	paths.push(path.join(CONFIG_DIR, "skills"));
+	paths.push(path.join(os.homedir(), ".agents", "skills"));
+	const extraDirs = (config?.skills?.load?.extraDirs ?? []).map((d) => typeof d === "string" ? d.trim() : "").filter(Boolean).map((dir) => resolveUserPath(dir));
+	paths.push(...extraDirs);
+	const pluginSkillDirs = resolvePluginSkillDirs({
+		workspaceDir,
+		config
+	});
+	paths.push(...pluginSkillDirs);
+	return paths;
+}
+function toWatchGlobRoot(raw) {
+	return raw.replaceAll("\\", "/").replace(/\/+$/, "");
+}
+function resolveWatchTargets(workspaceDir, config) {
+	const targets = /* @__PURE__ */ new Set();
+	for (const root of resolveWatchPaths(workspaceDir, config)) {
+		const globRoot = toWatchGlobRoot(root);
+		targets.add(`${globRoot}/SKILL.md`);
+		targets.add(`${globRoot}/*/SKILL.md`);
+	}
+	return Array.from(targets).toSorted();
+}
+function bumpSkillsSnapshotVersion(params) {
+	const reason = params?.reason ?? "manual";
+	const changedPath = params?.changedPath;
+	if (params?.workspaceDir) {
+		const next = bumpVersion(workspaceVersions.get(params.workspaceDir) ?? 0);
+		workspaceVersions.set(params.workspaceDir, next);
+		emit({
+			workspaceDir: params.workspaceDir,
+			reason,
+			changedPath
+		});
+		return next;
+	}
+	globalVersion = bumpVersion(globalVersion);
+	emit({
+		reason,
+		changedPath
+	});
+	return globalVersion;
+}
+function getSkillsSnapshotVersion(workspaceDir) {
+	if (!workspaceDir) return globalVersion;
+	const local = workspaceVersions.get(workspaceDir) ?? 0;
+	return Math.max(globalVersion, local);
+}
+function ensureSkillsWatcher(params) {
+	const workspaceDir = params.workspaceDir.trim();
+	if (!workspaceDir) return;
+	const watchEnabled = params.config?.skills?.load?.watch !== false;
+	const debounceMsRaw = params.config?.skills?.load?.watchDebounceMs;
+	const debounceMs = typeof debounceMsRaw === "number" && Number.isFinite(debounceMsRaw) ? Math.max(0, debounceMsRaw) : 250;
+	const existing = watchers.get(workspaceDir);
+	if (!watchEnabled) {
+		if (existing) {
+			watchers.delete(workspaceDir);
+			if (existing.timer) clearTimeout(existing.timer);
+			existing.watcher.close().catch(() => {});
+		}
+		return;
+	}
+	const watchTargets = resolveWatchTargets(workspaceDir, params.config);
+	const pathsKey = watchTargets.join("|");
+	if (existing && existing.pathsKey === pathsKey && existing.debounceMs === debounceMs) return;
+	if (existing) {
+		watchers.delete(workspaceDir);
+		if (existing.timer) clearTimeout(existing.timer);
+		existing.watcher.close().catch(() => {});
+	}
+	const watcher = chokidar.watch(watchTargets, {
+		ignoreInitial: true,
+		awaitWriteFinish: {
+			stabilityThreshold: debounceMs,
+			pollInterval: 100
+		},
+		ignored: DEFAULT_SKILLS_WATCH_IGNORED
+	});
+	const state = {
+		watcher,
+		pathsKey,
+		debounceMs
+	};
+	const schedule = (changedPath) => {
+		state.pendingPath = changedPath ?? state.pendingPath;
+		if (state.timer) clearTimeout(state.timer);
+		state.timer = setTimeout(() => {
+			const pendingPath = state.pendingPath;
+			state.pendingPath = void 0;
+			state.timer = void 0;
+			bumpSkillsSnapshotVersion({
+				workspaceDir,
+				reason: "watch",
+				changedPath: pendingPath
+			});
+		}, debounceMs);
+	};
+	watcher.on("add", (p) => schedule(p));
+	watcher.on("change", (p) => schedule(p));
+	watcher.on("unlink", (p) => schedule(p));
+	watcher.on("error", (err) => {
+		log$1.warn(`skills watcher error (${workspaceDir}): ${String(err)}`);
+	});
+	watchers.set(workspaceDir, state);
+}
+
+//#endregion
+//#region src/infra/node-pairing.ts
+const PENDING_TTL_MS = 300 * 1e3;
+const withLock = createAsyncLock();
+
+//#endregion
+//#region src/infra/skills-remote.ts
+const log = createSubsystemLogger("gateway/skills-remote");
+const remoteNodes = /* @__PURE__ */ new Map();
+function isMacPlatform(platform, deviceFamily) {
+	const platformNorm = String(platform ?? "").trim().toLowerCase();
+	const familyNorm = String(deviceFamily ?? "").trim().toLowerCase();
+	if (platformNorm.includes("mac")) return true;
+	if (platformNorm.includes("darwin")) return true;
+	if (familyNorm === "mac") return true;
+	return false;
+}
+function supportsSystemRun(commands) {
+	return Array.isArray(commands) && commands.includes("system.run");
+}
+function getRemoteSkillEligibility() {
+	const macNodes = [...remoteNodes.values()].filter((node) => isMacPlatform(node.platform, node.deviceFamily) && supportsSystemRun(node.commands));
+	if (macNodes.length === 0) return;
+	const bins = /* @__PURE__ */ new Set();
+	for (const node of macNodes) for (const bin of node.bins) bins.add(bin);
+	const labels = macNodes.map((node) => node.displayName ?? node.nodeId).filter(Boolean);
+	return {
+		platforms: ["darwin"],
+		hasBin: (bin) => bins.has(bin),
+		hasAnyBin: (required) => required.some((bin) => bins.has(bin)),
+		note: labels.length > 0 ? `Remote macOS node available (${labels.join(", ")}). Run macOS-only skills via nodes.run on that node.` : "Remote macOS node available. Run macOS-only skills via nodes.run on that node."
+	};
+}
+
+//#endregion
+//#region src/auto-reply/skill-commands.ts
+function listReservedChatSlashCommandNames(extraNames = []) {
+	const reserved = /* @__PURE__ */ new Set();
+	for (const command of listChatCommands()) {
+		if (command.nativeName) reserved.add(command.nativeName.toLowerCase());
+		for (const alias of command.textAliases) {
+			const trimmed = alias.trim();
+			if (!trimmed.startsWith("/")) continue;
+			reserved.add(trimmed.slice(1).toLowerCase());
+		}
+	}
+	for (const name of extraNames) {
+		const trimmed = name.trim().toLowerCase();
+		if (trimmed) reserved.add(trimmed);
+	}
+	return reserved;
+}
+function listSkillCommandsForWorkspace(params) {
+	return buildWorkspaceSkillCommandSpecs(params.workspaceDir, {
+		config: params.cfg,
+		skillFilter: params.skillFilter,
+		eligibility: { remote: getRemoteSkillEligibility() },
+		reservedNames: listReservedChatSlashCommandNames()
+	});
+}
+function listSkillCommandsForAgents(params) {
+	const mergeSkillFilters = (existing, incoming) => {
+		if (existing === void 0 || incoming === void 0) return;
+		if (existing.length === 0) return Array.from(new Set(incoming));
+		if (incoming.length === 0) return Array.from(new Set(existing));
+		return Array.from(new Set([...existing, ...incoming]));
+	};
+	const agentIds = params.agentIds ?? listAgentIds(params.cfg);
+	const used = listReservedChatSlashCommandNames();
+	const entries = [];
+	const workspaceFilters = /* @__PURE__ */ new Map();
+	for (const agentId of agentIds) {
+		const workspaceDir = resolveAgentWorkspaceDir(params.cfg, agentId);
+		if (!fs.existsSync(workspaceDir)) {
+			logVerbose(`Skipping agent "${agentId}": workspace does not exist: ${workspaceDir}`);
+			continue;
+		}
+		let canonicalDir;
+		try {
+			canonicalDir = fs.realpathSync(workspaceDir);
+		} catch {
+			logVerbose(`Skipping agent "${agentId}": cannot resolve workspace: ${workspaceDir}`);
+			continue;
+		}
+		const skillFilter = resolveAgentSkillsFilter(params.cfg, agentId);
+		const existing = workspaceFilters.get(canonicalDir);
+		if (existing) {
+			existing.skillFilter = mergeSkillFilters(existing.skillFilter, skillFilter);
+			continue;
+		}
+		workspaceFilters.set(canonicalDir, {
+			workspaceDir,
+			skillFilter
+		});
+	}
+	for (const { workspaceDir, skillFilter } of workspaceFilters.values()) {
+		const commands = buildWorkspaceSkillCommandSpecs(workspaceDir, {
+			config: params.cfg,
+			skillFilter,
+			eligibility: { remote: getRemoteSkillEligibility() },
+			reservedNames: used
+		});
+		for (const command of commands) {
+			used.add(command.name.toLowerCase());
+			entries.push(command);
+		}
+	}
+	return entries;
+}
+function normalizeSkillCommandLookup(value) {
+	return value.trim().toLowerCase().replace(/[\s_]+/g, "-");
+}
+function findSkillCommand(skillCommands, rawName) {
+	const trimmed = rawName.trim();
+	if (!trimmed) return;
+	const lowered = trimmed.toLowerCase();
+	const normalized = normalizeSkillCommandLookup(trimmed);
+	return skillCommands.find((entry) => {
+		if (entry.name.toLowerCase() === lowered) return true;
+		if (entry.skillName.toLowerCase() === lowered) return true;
+		return normalizeSkillCommandLookup(entry.name) === normalized || normalizeSkillCommandLookup(entry.skillName) === normalized;
+	});
+}
+function resolveSkillCommandInvocation(params) {
+	const trimmed = params.commandBodyNormalized.trim();
+	if (!trimmed.startsWith("/")) return null;
+	const match = trimmed.match(/^\/([^\s]+)(?:\s+([\s\S]+))?$/);
+	if (!match) return null;
+	const commandName = match[1]?.trim().toLowerCase();
+	if (!commandName) return null;
+	if (commandName === "skill") {
+		const remainder = match[2]?.trim();
+		if (!remainder) return null;
+		const skillMatch = remainder.match(/^([^\s]+)(?:\s+([\s\S]+))?$/);
+		if (!skillMatch) return null;
+		const skillCommand = findSkillCommand(params.skillCommands, skillMatch[1] ?? "");
+		if (!skillCommand) return null;
+		return {
+			command: skillCommand,
+			args: skillMatch[2]?.trim() || void 0
+		};
+	}
+	const command = params.skillCommands.find((entry) => entry.name.toLowerCase() === commandName);
+	if (!command) return null;
+	return {
+		command,
+		args: match[2]?.trim() || void 0
+	};
+}
+
+//#endregion
+export { getRemoteSkillEligibility as a, generatePairingToken as c, resolvePairingPaths as d, resolveSkillCommandInvocation as i, rejectPendingPairingRequest as l, listSkillCommandsForAgents as n, ensureSkillsWatcher as o, listSkillCommandsForWorkspace as r, getSkillsSnapshotVersion as s, listReservedChatSlashCommandNames as t, pruneExpiredPending as u };

package/dist/plugin-sdk/{skill-commands-DoRqLzxm.js → skill-commands-DZqhtmiv.js}

@@ -1,9 +1,9 @@
-import { c as resolveAgentWorkspaceDir, r as listAgentIds, s as resolveAgentSkillsFilter } from "./run-with-concurrency-BR1DXa8T.js";
-import { L as logVerbose, O as createSubsystemLogger, a as CONFIG_DIR, y as resolveUserPath } from "./logger-DHIIvMxj.js";
+import { c as resolveAgentWorkspaceDir, r as listAgentIds, s as resolveAgentSkillsFilter } from "./run-with-concurrency-C_KCHwvf.js";
+import { L as logVerbose, O as createSubsystemLogger, a as CONFIG_DIR, y as resolveUserPath } from "./logger-CvPFVOgT.js";
 import { c as resolveStateDir } from "./paths-0d8fBoC4.js";
 import { t as createAsyncLock } from "./json-files-DtF9ARSD.js";
-import { o as resolvePluginSkillDirs, t as buildWorkspaceSkillCommandSpecs } from "./skills-QudILG6e.js";
-import { i as listChatCommands } from "./commands-registry-BJ_NxG2F.js";
+import { o as resolvePluginSkillDirs, t as buildWorkspaceSkillCommandSpecs } from "./skills-Cw_vXEJb.js";
+import { i as listChatCommands } from "./commands-registry-CdYjoI0i.js";
 import path from "node:path";
 import fs from "node:fs";
 import os from "node:os";