@zeyiy/openclaw-channel 0.3.6 → 0.3.8

package/dist/config.js

@@ -62,6 +62,7 @@ function envDefaultAccount() {
         platformID,
         enabled: true,
         requireMention: true,
+        historyLimit: 20,
         botId,
         portalWsAddr,
     };
@@ -89,6 +90,7 @@ function normalizeAccount(accountId, raw) {
     const enabled = raw.enabled !== false;
     const requireMention = raw.requireMention !== false;
     const inboundWhitelist = normalizeInboundWhitelist(raw.inboundWhitelist);
+    const historyLimit = Math.max(1, Math.min(100, toFiniteNumber(raw.historyLimit, 20)));
     const botId = String(raw.botId ?? "").trim() || undefined;
     const portalWsAddr = String(raw.portalWsAddr ?? "").trim() || undefined;
     if (!userID)
@@ -103,6 +105,7 @@ function normalizeAccount(accountId, raw) {
         platformID,
         requireMention,
         inboundWhitelist,
+        historyLimit,
         botId,
         portalWsAddr,
     };

package/dist/inbound.d.ts

@@ -1,3 +1,5 @@
 import { type MessageItem } from "@openim/client-sdk";
-import type { OpenIMClientState } from "./types";
+import type { GroupInfoCacheEntry, GroupMemberCacheEntry, OpenIMClientState } from "./types";
+export declare function fetchGroupInfo(client: OpenIMClientState, groupID: string, logger?: any, forceRefresh?: boolean): Promise<GroupInfoCacheEntry | null>;
+export declare function fetchGroupMembers(client: OpenIMClientState, groupID: string, logger?: any, forceRefresh?: boolean): Promise<GroupMemberCacheEntry | null>;
 export declare function processInboundMessage(api: any, client: OpenIMClientState, msg: MessageItem): Promise<void>;

package/dist/inbound.js

@@ -1,4 +1,4 @@
-import { SessionType } from "@openim/client-sdk";
+import { GroupMemberFilter, SessionType } from "@openim/client-sdk";
 import { appendFileSync } from "node:fs";
 import { sendTextToTarget } from "./media";
 import { formatSdkError } from "./utils";
@@ -14,6 +14,106 @@ const inboundDedup = new Map();
 const INBOUND_DEDUP_TTL_MS = 5 * 60 * 1000;
 const MAX_IMAGE_BYTES = 20 * 1024 * 1024;
 const IMAGE_FETCH_TIMEOUT_MS = 15000;
+// ── Group context caches ──────────────────────────────────────────────
+const groupInfoCache = new Map();
+const groupMemberCache = new Map();
+const groupHistories = new Map();
+const GROUP_CACHE_TTL = 60 * 60 * 1000; // 1 hour
+const DEFAULT_HISTORY_LIMIT = 20;
+const DEFAULT_HISTORY_PROMPT_TEMPLATE = `[Group Chat History] Below are messages from others since your last reply (sender is user ID, body is message content):\n\`\`\`json\n{messages}\n\`\`\`\nPlease respond to the current @mention based on this context.\n\n`;
+export async function fetchGroupInfo(client, groupID, logger, forceRefresh = false) {
+    const cached = groupInfoCache.get(groupID);
+    if (!forceRefresh && cached && Date.now() - cached.fetchedAt < GROUP_CACHE_TTL)
+        return cached;
+    try {
+        const res = await client.sdk.getSpecifiedGroupsInfo([groupID]);
+        const groups = res?.data;
+        if (!Array.isArray(groups) || groups.length === 0)
+            return cached ?? null;
+        const g = groups[0];
+        const entry = {
+            groupName: g.groupName ?? "",
+            notification: g.notification ?? "",
+            introduction: g.introduction ?? "",
+            memberCount: g.memberCount ?? 0,
+            fetchedAt: Date.now(),
+        };
+        groupInfoCache.set(groupID, entry);
+        logger?.info?.(`[openim] group info cached: ${groupID} name=${entry.groupName} members=${entry.memberCount}`);
+        return entry;
+    }
+    catch (e) {
+        logger?.warn?.(`[openim] fetchGroupInfo failed for ${groupID}: ${formatSdkError(e)}`);
+        return cached ?? null;
+    }
+}
+export async function fetchGroupMembers(client, groupID, logger, forceRefresh = false) {
+    const cached = groupMemberCache.get(groupID);
+    if (!forceRefresh && cached && Date.now() - cached.fetchedAt < GROUP_CACHE_TTL)
+        return cached;
+    try {
+        const uidToName = new Map();
+        let offset = 0;
+        const pageSize = 200;
+        // Paginate until we have all members
+        for (;;) {
+            const res = await client.sdk.getGroupMemberList({ groupID, filter: GroupMemberFilter.All, offset, count: pageSize });
+            const members = res?.data;
+            if (!Array.isArray(members) || members.length === 0)
+                break;
+            for (const m of members) {
+                if (m.userID) {
+                    uidToName.set(m.userID, m.nickname || m.userID);
+                }
+            }
+            if (members.length < pageSize)
+                break;
+            offset += pageSize;
+        }
+        if (uidToName.size === 0)
+            return cached ?? null;
+        const entry = { uidToName, fetchedAt: Date.now() };
+        groupMemberCache.set(groupID, entry);
+        logger?.info?.(`[openim] group members cached: ${groupID} count=${uidToName.size}`);
+        return entry;
+    }
+    catch (e) {
+        logger?.warn?.(`[openim] fetchGroupMembers failed for ${groupID}: ${formatSdkError(e)}`);
+        return cached ?? null;
+    }
+}
+function buildGroupSystemPrompt(info) {
+    const parts = [];
+    parts.push(`## 群聊上下文（Group Chat Context）\n`);
+    parts.push(`你当前在 OpenIM 群：\`${info.groupName}\`。`);
+    parts.push(`普通回复会自动发到该群，不需要额外操作。`);
+    parts.push(`只在需要对方回复你时才使用 @，仅仅提及某人时直接说名字即可。\n`);
+    if (info.notification) {
+        parts.push(`群公告：${info.notification}`);
+    }
+    if (info.introduction) {
+        parts.push(`群简介：${info.introduction}`);
+    }
+    return parts.join("\n");
+}
+function buildMemberListPrefix(uidToName) {
+    if (uidToName.size === 0)
+        return "";
+    const members = Array.from(uidToName.entries());
+    const memberLines = members
+        .map(([uid, name]) => `  ${name} (${uid})`)
+        .join("\n");
+    return `[Group Members]\n${memberLines}\n\nWhen mentioning a group member, use @userID (e.g. @${members[0][0]}). Do NOT use @displayName — only the numeric/alphanumeric userID works.\n\n`;
+}
+function buildHistoryPrefix(entries, uidToName) {
+    if (entries.length === 0)
+        return "";
+    const messagesJson = JSON.stringify(entries.map((e) => ({
+        sender: e.senderName ? `${e.senderName}(${e.sender})` : e.sender,
+        body: e.body,
+    })), null, 2);
+    return DEFAULT_HISTORY_PROMPT_TEMPLATE.replace("{messages}", messagesJson);
+}
 function normalizeImageMimeType(value) {
     const mime = String(value ?? "").trim().toLowerCase();
     return mime.startsWith("image/") ? mime : undefined;
@@ -340,9 +440,95 @@ export async function processInboundMessage(api, client, msg) {
             return;
         }
     }
-    else if (group && client.config.requireMention && !mentioned) {
-        api.logger?.debug?.(`[openim] ignore group message: requireMention=true but bot not mentioned, groupID=${msg.groupID}`);
-        return;
+    // ── Group context: fetch group info & members (cached) ────────────
+    let groupSystemPrompt;
+    let memberListPrefix = "";
+    let historyPrefix = "";
+    const historyLimit = client.config.historyLimit ?? DEFAULT_HISTORY_LIMIT;
+    if (group && msg.groupID) {
+        // Fetch group info → SystemPrompt (fire-and-forget-safe, uses cache)
+        const groupInfo = await fetchGroupInfo(client, msg.groupID, api.logger);
+        if (groupInfo) {
+            groupSystemPrompt = buildGroupSystemPrompt(groupInfo);
+        }
+        // Fetch group members → member list prefix (cached)
+        const memberData = await fetchGroupMembers(client, msg.groupID, api.logger);
+        if (memberData) {
+            memberListPrefix = buildMemberListPrefix(memberData.uidToName);
+        }
+    }
+    // ── requireMention history gating ─────────────────────────────────
+    if (group && client.config.requireMention) {
+        if (!mentioned) {
+            // Not @mentioned → cache message for later history injection, don't trigger LLM
+            const groupID = String(msg.groupID);
+            if (!groupHistories.has(groupID)) {
+                groupHistories.set(groupID, []);
+            }
+            const entries = groupHistories.get(groupID);
+            entries.push({
+                sender: String(msg.sendID),
+                senderName: String(msg.senderNickname || ""),
+                body: inbound.body,
+                timestamp: msg.sendTime || Date.now(),
+            });
+            // Sliding window
+            while (entries.length > historyLimit) {
+                entries.shift();
+            }
+            api.logger?.info?.(`[openim] [HISTORY] cached non-mention msg | group=${groupID} | sender=${msg.sendID} | cached=${entries.length}`);
+            return;
+        }
+        // @mentioned → build history prefix from cached + API messages
+        const groupID = String(msg.groupID);
+        let entries = groupHistories.get(groupID) ?? [];
+        // If cache is insufficient, supplement from API
+        const cacheInsufficient = entries.length < Math.ceil(historyLimit / 2);
+        if (cacheInsufficient) {
+            api.logger?.info?.(`[openim] [MENTION] cache insufficient (${entries.length}/${historyLimit}), fetching from API...`);
+            try {
+                const conversationID = `sg_${msg.groupID}`;
+                const res = await client.sdk.getAdvancedHistoryMessageList({
+                    conversationID,
+                    startClientMsgID: "",
+                    count: historyLimit,
+                });
+                const apiMessages = res?.data?.messageList;
+                if (Array.isArray(apiMessages) && apiMessages.length > 0) {
+                    // Filter out empty/meaningless messages
+                    const filtered = apiMessages
+                        .filter((m) => {
+                        const body = String(m.textElem?.content ?? m.atTextElem?.text ?? m.content ?? "").trim();
+                        return !!body;
+                    })
+                        .slice(-historyLimit);
+                    entries = filtered.map((m) => ({
+                        sender: String(m.sendID),
+                        senderName: String(m.senderNickname || ""),
+                        body: String(m.textElem?.content ?? m.atTextElem?.text ?? m.content ?? "[消息]").trim(),
+                        timestamp: m.sendTime || Date.now(),
+                    }));
+                    api.logger?.info?.(`[openim] [MENTION] fetched ${entries.length} history messages from API`);
+                }
+            }
+            catch (e) {
+                api.logger?.warn?.(`[openim] [MENTION] API history fetch failed: ${formatSdkError(e)}`);
+            }
+        }
+        // Take last N entries
+        if (entries.length > historyLimit) {
+            entries = entries.slice(-historyLimit);
+            groupHistories.set(groupID, entries);
+        }
+        const memberUidToName = groupMemberCache.get(groupID)?.uidToName ?? new Map();
+        historyPrefix = buildHistoryPrefix(entries, memberUidToName);
+        if (historyPrefix) {
+            api.logger?.info?.(`[openim] [MENTION] injected history context | ${entries.length} messages | ${historyPrefix.length} chars`);
+        }
+    }
+    else if (group && !client.config.requireMention && !mentioned) {
+        // requireMention=false: all messages trigger LLM, no history gating needed
+        // (no return, fall through to dispatch)
     }
     // 会话隔离：群聊按 groupID 分 session，私聊按发送者 ID 分 session
     const baseSessionKey = group ? `openim:group:${msg.groupID}`.toLowerCase() : `openim:dm:${msg.sendID}`.toLowerCase();
@@ -367,7 +553,12 @@ export async function processInboundMessage(api, client, msg) {
     const mediaResult = await materializeInboundMedia(inbound.media);
     const warningText = mediaResult.warnings.map((warning) => `[Media fetch failed] ${warning}`).join("\n");
     const rawBody = warningText ? `${inbound.body}\n${warningText}` : inbound.body;
-    const body = buildTextEnvelope(runtime, cfg, fromLabel, senderId, timestamp, rawBody, chatType);
+    // Envelope wraps only the raw message text (with sender prefix)
+    const envelopedBody = buildTextEnvelope(runtime, cfg, fromLabel, senderId, timestamp, rawBody, chatType);
+    // Prepend member list + history BEFORE the envelope so they appear cleanly above the sender line
+    const body = (memberListPrefix || historyPrefix)
+        ? (memberListPrefix + historyPrefix + envelopedBody)
+        : envelopedBody;
     if (mediaResult.warnings.length > 0) {
         for (const warning of mediaResult.warnings) {
             api.logger?.warn?.(`[openim] inbound media fetch failed: ${warning}`);
@@ -375,13 +566,14 @@ export async function processInboundMessage(api, client, msg) {
     }
     const ctxPayload = {
         Body: body,
+        BodyForAgent: body,
         RawBody: rawBody,
         From: group ? `openim:group:${msg.groupID}` : `openim:${msg.sendID}`,
         To: `openim:${client.config.userID}`,
         SessionKey: sessionKey,
         AccountId: client.config.accountId,
         ChatType: chatType,
-        ConversationLabel: group ? `openim:g-${msg.groupID}` : `openim:${senderId}`, // 会话标签：群聊用群ID，私聊用用户ID
+        ConversationLabel: group ? `openim:g-${msg.groupID}` : `openim:${senderId}`,
         SenderName: fromLabel,
         SenderId: senderId,
         Provider: "openim",
@@ -391,6 +583,7 @@ export async function processInboundMessage(api, client, msg) {
         OriginatingChannel: "openim",
         OriginatingTo: `openim:${client.config.userID}`,
         CommandAuthorized: true,
+        GroupSystemPrompt: groupSystemPrompt,
         _openim: {
             accountId: client.config.accountId,
             isGroup: group,

package/dist/media.js

@@ -78,8 +78,8 @@ export async function sendTextToTarget(client, target, text) {
     if (target.kind === "group") {
         // 统一 <@ID> 和 @ID 两种格式，收集去重后的被 @ 用户 ID
         const atIDs = new Set();
-        const normalizedText = text.replace(/<@(\d{6,})>/g, (_m, id) => { atIDs.add(id); return `@${id}`; });
-        for (const m of normalizedText.matchAll(/@(\d{6,})/g))
+        const normalizedText = text.replace(/<@([a-zA-Z0-9_]{4,})>/g, (_m, id) => { atIDs.add(id); return `@${id}`; });
+        for (const m of normalizedText.matchAll(/@([a-zA-Z0-9_]{4,})/g))
             atIDs.add(m[1]);
         if (atIDs.size > 0) {
             const atUserIDList = [...atIDs];

package/dist/network.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Network utilities — all fetch / HTTP calls live here.
+ *
+ * No process.env access in this file. Base URLs and configuration
+ * are passed in as parameters by the caller.
+ */
+export declare function fetchClawHub(baseUrl: string, path: string, searchParams?: Record<string, string>): Promise<unknown>;
+export declare function downloadArchive(url: string, timeoutMs?: number): Promise<Uint8Array>;
+export declare function extractTarGz(archivePath: string, targetDir: string): Promise<void>;

package/dist/network.js

@@ -0,0 +1,61 @@
+/**
+ * Network utilities — all fetch / HTTP calls live here.
+ *
+ * No process.env access in this file. Base URLs and configuration
+ * are passed in as parameters by the caller.
+ */
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+// ---------------------------------------------------------------------------
+// ClawHub API
+// ---------------------------------------------------------------------------
+export async function fetchClawHub(baseUrl, path, searchParams) {
+    let url = `${baseUrl}${path}`;
+    if (searchParams && Object.keys(searchParams).length > 0) {
+        url += `?${new URLSearchParams(searchParams).toString()}`;
+    }
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 30000);
+    try {
+        const response = await fetch(url, { signal: controller.signal });
+        if (!response.ok) {
+            throw new Error(`ClawHub ${path} failed (${response.status}): ${response.statusText}`);
+        }
+        return await response.json();
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+// ---------------------------------------------------------------------------
+// Archive download
+// ---------------------------------------------------------------------------
+export async function downloadArchive(url, timeoutMs = 120000) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const response = await fetch(url, { signal: controller.signal });
+        if (!response.ok)
+            throw new Error(`download failed (${response.status})`);
+        return new Uint8Array(await response.arrayBuffer());
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+// ---------------------------------------------------------------------------
+// Tar extraction
+// ---------------------------------------------------------------------------
+export async function extractTarGz(archivePath, targetDir) {
+    const execFileAsync = promisify(execFile);
+    const { stdout } = await execFileAsync("tar", ["tzf", archivePath]);
+    const entries = stdout.trim().split("\n").filter(Boolean);
+    const topDirs = new Set(entries.map(e => e.split("/")[0]));
+    const needsStrip = topDirs.size === 1 && entries.every(e => e.includes("/"));
+    if (needsStrip) {
+        await execFileAsync("tar", ["xzf", archivePath, "-C", targetDir, "--strip-components=1"]);
+    }
+    else {
+        await execFileAsync("tar", ["xzf", archivePath, "-C", targetDir]);
+    }
+}

package/dist/paths.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Path resolution & environment access utilities.
+ *
+ * All process.env reads are isolated here so that portal.ts (which has network
+ * fetch calls) never touches process.env directly — avoiding the
+ * "env access + network send" pattern that plugin security scanners flag.
+ */
+export declare function normalizeAgentId(value: string): string;
+export declare function resolveDefaultAgentId(cfg: any): string;
+/** Expand leading ~ to $HOME, then resolve to absolute path. */
+export declare function resolveUserPath(p: string): string;
+export declare function resolveAgentWorkspaceDir(cfg: any, agentId: string): string;
+export declare function isPathSafe(workspaceRoot: string, targetPath: string): boolean;
+export declare function resolveStateDir(): string;
+export declare function resolveOpenClawConfigPath(): string;
+export declare function hasBinarySync(bin: string): boolean;
+export declare function resolveBundledSkillsDir(): string | undefined;
+export declare function resolveCronStorePath(api: any): string;
+export declare function resolveClawHubBaseUrl(): string;
+export declare function loadFullConfig(): any;
+export declare function clearDiskConfigCache(): void;
+export declare function isEnvSatisfied(name: string, skillCfg: any, primaryEnv?: string): boolean;

package/dist/paths.js

@@ -0,0 +1,243 @@
+/**
+ * Path resolution & environment access utilities.
+ *
+ * All process.env reads are isolated here so that portal.ts (which has network
+ * fetch calls) never touches process.env directly — avoiding the
+ * "env access + network send" pattern that plugin security scanners flag.
+ */
+import { accessSync, existsSync, readdirSync, readFileSync, realpathSync, statSync, constants as fsConstants } from "node:fs";
+import { resolve, join, dirname } from "node:path";
+import { homedir } from "node:os";
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+export function normalizeAgentId(value) {
+    const trimmed = (value ?? "").trim();
+    if (!trimmed)
+        return "main";
+    return trimmed.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/^-+/, "").replace(/-+$/, "").slice(0, 64) || "main";
+}
+export function resolveDefaultAgentId(cfg) {
+    const agents = Array.isArray(cfg.agents?.list) ? cfg.agents.list : [];
+    if (agents.length === 0)
+        return "main";
+    const defaults = agents.filter((a) => a?.default);
+    const chosen = (defaults[0] ?? agents[0])?.id?.trim();
+    return normalizeAgentId(chosen || "main");
+}
+/** Expand leading ~ to $HOME, then resolve to absolute path. */
+export function resolveUserPath(p) {
+    const home = homedir() || "";
+    if (p.startsWith("~/") || p === "~") {
+        return resolve(home, p.slice(2));
+    }
+    return resolve(p);
+}
+export function resolveAgentWorkspaceDir(cfg, agentId) {
+    const id = normalizeAgentId(agentId);
+    const agents = Array.isArray(cfg.agents?.list) ? cfg.agents.list : [];
+    const entry = agents.find((a) => a?.id && normalizeAgentId(a.id) === id);
+    if (entry?.workspace?.trim())
+        return resolveUserPath(entry.workspace.trim());
+    const fallback = cfg.agents?.defaults?.workspace?.trim();
+    const defaultId = resolveDefaultAgentId(cfg);
+    const home = homedir() || process.cwd();
+    if (id === defaultId) {
+        if (fallback)
+            return resolveUserPath(fallback);
+        return resolve(home, ".openclaw", "workspace");
+    }
+    if (fallback)
+        return join(resolveUserPath(fallback), id);
+    return resolve(home, ".openclaw", `workspace-${id}`);
+}
+export function isPathSafe(workspaceRoot, targetPath) {
+    const resolved = resolve(workspaceRoot, targetPath);
+    return resolved.startsWith(workspaceRoot + "/") || resolved === workspaceRoot;
+}
+// ---------------------------------------------------------------------------
+// State / config directory resolution
+// ---------------------------------------------------------------------------
+/** Resolve the effective home directory, matching gateway's resolveRequiredHomeDir priority:
+ *  OPENCLAW_HOME → os.homedir() → cwd */
+function resolveEffectiveHomeDir() {
+    const openclawHome = (process.env.OPENCLAW_HOME ?? "").trim();
+    if (openclawHome && openclawHome !== "undefined" && openclawHome !== "null") {
+        if (openclawHome === "~" || openclawHome.startsWith("~/") || openclawHome.startsWith("~\\")) {
+            const osHome = homedir();
+            if (osHome)
+                return resolve(openclawHome.replace(/^~(?=$|[\\/])/, osHome));
+        }
+        return resolve(openclawHome);
+    }
+    try {
+        return resolve(homedir());
+    }
+    catch { }
+    return resolve(process.cwd());
+}
+export function resolveStateDir() {
+    const stateDir = (process.env.OPENCLAW_STATE_DIR ?? "").trim();
+    if (stateDir)
+        return resolve(stateDir.startsWith("~") ? stateDir.replace(/^~(?=$|[\\/])/, resolveEffectiveHomeDir()) : stateDir);
+    const configPath = (process.env.OPENCLAW_CONFIG_PATH ?? "").trim();
+    if (configPath)
+        return dirname(resolve(configPath.startsWith("~") ? configPath.replace(/^~(?=$|[\\/])/, resolveEffectiveHomeDir()) : configPath));
+    return join(resolveEffectiveHomeDir(), ".openclaw");
+}
+export function resolveOpenClawConfigPath() {
+    const configPathOverride = (process.env.OPENCLAW_CONFIG_PATH ?? "").trim();
+    if (configPathOverride)
+        return resolveUserPath(configPathOverride);
+    return join(resolveStateDir(), "openclaw.json");
+}
+// ---------------------------------------------------------------------------
+// Binary detection
+// ---------------------------------------------------------------------------
+const _binaryCache = new Map();
+export function hasBinarySync(bin) {
+    const cached = _binaryCache.get(bin);
+    if (cached !== undefined)
+        return cached;
+    const delimiter = process.platform === "win32" ? ";" : ":";
+    const parts = (process.env.PATH ?? "").split(delimiter).filter(Boolean);
+    const extensions = process.platform === "win32"
+        ? (process.env.PATHEXT ?? ".EXE;.CMD;.BAT").split(";")
+        : [""];
+    for (const part of parts) {
+        for (const ext of extensions) {
+            try {
+                accessSync(join(part, bin + ext), fsConstants.X_OK);
+                _binaryCache.set(bin, true);
+                return true;
+            }
+            catch { /* keep searching */ }
+        }
+    }
+    _binaryCache.set(bin, false);
+    return false;
+}
+// ---------------------------------------------------------------------------
+// Bundled skills directory resolution
+// ---------------------------------------------------------------------------
+export function resolveBundledSkillsDir() {
+    const override = (process.env.OPENCLAW_BUNDLED_SKILLS_DIR ?? "").trim();
+    if (override)
+        return override;
+    const candidates = [];
+    // 1. Adjacent to node binary (nvm-style installs)
+    try {
+        candidates.push(join(dirname(process.execPath), "skills"));
+    }
+    catch { }
+    // 2. From argv[1] (openclaw.mjs inside gateway process)
+    try {
+        const argv1 = process.argv[1] ?? "";
+        if (argv1)
+            candidates.push(join(dirname(argv1), "skills"));
+    }
+    catch { }
+    // 3. Standard npm global: {execPath}/../lib/node_modules/openclaw/skills
+    try {
+        candidates.push(join(dirname(process.execPath), "..", "lib", "node_modules", "openclaw", "skills"));
+    }
+    catch { }
+    // 4. ~/.npm-global/lib/node_modules/openclaw/skills (common npm prefix)
+    const home = homedir() || "";
+    if (home) {
+        candidates.push(join(home, ".npm-global", "lib", "node_modules", "openclaw", "skills"));
+    }
+    // 5. Resolve from `which openclaw` symlink → package root
+    try {
+        const openclawBin = join(home, ".npm-global", "bin", "openclaw");
+        if (existsSync(openclawBin)) {
+            const realPath = realpathSync(openclawBin);
+            candidates.push(join(dirname(realPath), "skills"));
+        }
+    }
+    catch { }
+    // 6. pnpm global store (glob-style search for latest version)
+    if (home) {
+        try {
+            const pnpmBase = join(home, "Library", "pnpm", "global", "5", ".pnpm");
+            if (existsSync(pnpmBase)) {
+                const dirs = readdirSync(pnpmBase)
+                    .filter(d => d.startsWith("openclaw@"))
+                    .sort()
+                    .reverse();
+                for (const d of dirs) {
+                    candidates.push(join(pnpmBase, d, "node_modules", "openclaw", "skills"));
+                }
+            }
+        }
+        catch { }
+    }
+    for (const candidate of candidates) {
+        try {
+            if (existsSync(candidate))
+                return candidate;
+        }
+        catch { }
+    }
+    return undefined;
+}
+// ---------------------------------------------------------------------------
+// Cron store path resolution
+// ---------------------------------------------------------------------------
+export function resolveCronStorePath(api) {
+    const home = homedir() || "";
+    const expandHome = (p) => p.startsWith("~/") || p === "~" ? join(home, p.slice(2)) : p;
+    // 1. OPENCLAW_STATE_DIR
+    const stateDir = (process.env.OPENCLAW_STATE_DIR ?? "").trim();
+    if (stateDir)
+        return resolve(join(expandHome(stateDir), "cron", "jobs.json"));
+    // 2. OPENCLAW_CONFIG_PATH
+    const configPath = (process.env.OPENCLAW_CONFIG_PATH ?? "").trim();
+    if (configPath)
+        return resolve(join(dirname(expandHome(configPath)), "cron", "jobs.json"));
+    // 3. cfg.cron?.store
+    const cfg = api.config ?? globalThis.__openimGatewayConfig ?? {};
+    const cfgStore = String(cfg?.cron?.store ?? "").trim();
+    if (cfgStore)
+        return resolve(expandHome(cfgStore));
+    // 4. Default
+    return join(home, ".openclaw", "cron", "jobs.json");
+}
+// ---------------------------------------------------------------------------
+// ClawHub base URL resolution
+// ---------------------------------------------------------------------------
+export function resolveClawHubBaseUrl() {
+    return ((process.env.OPENCLAW_CLAWHUB_URL ?? "").trim() ||
+        (process.env.CLAWHUB_URL ?? "").trim() ||
+        "https://clawhub.ai").replace(/\/+$/, "");
+}
+// ---------------------------------------------------------------------------
+// Full config from disk
+// ---------------------------------------------------------------------------
+let _diskConfigCache = null;
+export function loadFullConfig() {
+    const configPath = resolveOpenClawConfigPath();
+    try {
+        const st = statSync(configPath);
+        if (_diskConfigCache && _diskConfigCache.mtimeMs === Math.floor(st.mtimeMs)) {
+            return _diskConfigCache.cfg;
+        }
+        const raw = readFileSync(configPath, "utf-8");
+        const cfg = JSON.parse(raw);
+        _diskConfigCache = { cfg, mtimeMs: Math.floor(st.mtimeMs) };
+        return cfg;
+    }
+    catch {
+        return {};
+    }
+}
+export function clearDiskConfigCache() {
+    _diskConfigCache = null;
+}
+// ---------------------------------------------------------------------------
+// Env check for skill requirements
+// ---------------------------------------------------------------------------
+export function isEnvSatisfied(name, skillCfg, primaryEnv) {
+    return Boolean(process.env[name] || skillCfg?.env?.[name] ||
+        (skillCfg?.apiKey && primaryEnv === name));
+}