clawdbot 2026.1.4-1

package/dist/agents/skills.js

@@ -0,0 +1,470 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { formatSkillsForPrompt, loadSkillsFromDir, } from "@mariozechner/pi-coding-agent";
+import { CONFIG_DIR, resolveUserPath } from "../utils.js";
+function resolveBundledSkillsDir() {
+    const override = process.env.CLAWDBOT_BUNDLED_SKILLS_DIR?.trim();
+    if (override)
+        return override;
+    // bun --compile: ship a sibling `skills/` next to the executable.
+    try {
+        const execDir = path.dirname(process.execPath);
+        const sibling = path.join(execDir, "skills");
+        if (fs.existsSync(sibling))
+            return sibling;
+    }
+    catch {
+        // ignore
+    }
+    // npm/dev: resolve `<packageRoot>/skills` relative to this module.
+    try {
+        const moduleDir = path.dirname(fileURLToPath(import.meta.url));
+        const root = path.resolve(moduleDir, "..", "..");
+        const candidate = path.join(root, "skills");
+        if (fs.existsSync(candidate))
+            return candidate;
+    }
+    catch {
+        // ignore
+    }
+    return undefined;
+}
+function getFrontmatterValue(frontmatter, key) {
+    const raw = frontmatter[key];
+    return typeof raw === "string" ? raw : undefined;
+}
+function stripQuotes(value) {
+    if ((value.startsWith('"') && value.endsWith('"')) ||
+        (value.startsWith("'") && value.endsWith("'"))) {
+        return value.slice(1, -1);
+    }
+    return value;
+}
+function parseFrontmatter(content) {
+    const frontmatter = {};
+    const normalized = content.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+    if (!normalized.startsWith("---"))
+        return frontmatter;
+    const endIndex = normalized.indexOf("\n---", 3);
+    if (endIndex === -1)
+        return frontmatter;
+    const block = normalized.slice(4, endIndex);
+    for (const line of block.split("\n")) {
+        const match = line.match(/^([\w-]+):\s*(.*)$/);
+        if (!match)
+            continue;
+        const key = match[1];
+        const value = stripQuotes(match[2].trim());
+        if (!key || !value)
+            continue;
+        frontmatter[key] = value;
+    }
+    return frontmatter;
+}
+function normalizeStringList(input) {
+    if (!input)
+        return [];
+    if (Array.isArray(input)) {
+        return input.map((value) => String(value).trim()).filter(Boolean);
+    }
+    if (typeof input === "string") {
+        return input
+            .split(",")
+            .map((value) => value.trim())
+            .filter(Boolean);
+    }
+    return [];
+}
+function parseInstallSpec(input) {
+    if (!input || typeof input !== "object")
+        return undefined;
+    const raw = input;
+    const kindRaw = typeof raw.kind === "string"
+        ? raw.kind
+        : typeof raw.type === "string"
+            ? raw.type
+            : "";
+    const kind = kindRaw.trim().toLowerCase();
+    if (kind !== "brew" && kind !== "node" && kind !== "go" && kind !== "uv") {
+        return undefined;
+    }
+    const spec = {
+        kind: kind,
+    };
+    if (typeof raw.id === "string")
+        spec.id = raw.id;
+    if (typeof raw.label === "string")
+        spec.label = raw.label;
+    const bins = normalizeStringList(raw.bins);
+    if (bins.length > 0)
+        spec.bins = bins;
+    if (typeof raw.formula === "string")
+        spec.formula = raw.formula;
+    if (typeof raw.package === "string")
+        spec.package = raw.package;
+    if (typeof raw.module === "string")
+        spec.module = raw.module;
+    return spec;
+}
+function isTruthy(value) {
+    if (value === undefined || value === null)
+        return false;
+    if (typeof value === "boolean")
+        return value;
+    if (typeof value === "number")
+        return value !== 0;
+    if (typeof value === "string")
+        return value.trim().length > 0;
+    return true;
+}
+const DEFAULT_CONFIG_VALUES = {
+    "browser.enabled": true,
+};
+export function resolveSkillsInstallPreferences(config) {
+    const raw = config?.skills?.install;
+    const preferBrew = raw?.preferBrew ?? true;
+    const managerRaw = typeof raw?.nodeManager === "string" ? raw.nodeManager.trim() : "";
+    const manager = managerRaw.toLowerCase();
+    const nodeManager = manager === "pnpm" ||
+        manager === "yarn" ||
+        manager === "bun" ||
+        manager === "npm"
+        ? manager
+        : "npm";
+    return { preferBrew, nodeManager };
+}
+export function resolveRuntimePlatform() {
+    return process.platform;
+}
+export function resolveConfigPath(config, pathStr) {
+    const parts = pathStr.split(".").filter(Boolean);
+    let current = config;
+    for (const part of parts) {
+        if (typeof current !== "object" || current === null)
+            return undefined;
+        current = current[part];
+    }
+    return current;
+}
+export function isConfigPathTruthy(config, pathStr) {
+    const value = resolveConfigPath(config, pathStr);
+    if (value === undefined && pathStr in DEFAULT_CONFIG_VALUES) {
+        return DEFAULT_CONFIG_VALUES[pathStr] === true;
+    }
+    return isTruthy(value);
+}
+export function resolveSkillConfig(config, skillKey) {
+    const skills = config?.skills?.entries;
+    if (!skills || typeof skills !== "object")
+        return undefined;
+    const entry = skills[skillKey];
+    if (!entry || typeof entry !== "object")
+        return undefined;
+    return entry;
+}
+function normalizeAllowlist(input) {
+    if (!input)
+        return undefined;
+    if (!Array.isArray(input))
+        return undefined;
+    const normalized = input.map((entry) => String(entry).trim()).filter(Boolean);
+    return normalized.length > 0 ? normalized : undefined;
+}
+function isBundledSkill(entry) {
+    return entry.skill.source === "clawdbot-bundled";
+}
+export function isBundledSkillAllowed(entry, allowlist) {
+    if (!allowlist || allowlist.length === 0)
+        return true;
+    if (!isBundledSkill(entry))
+        return true;
+    const key = resolveSkillKey(entry.skill, entry);
+    return allowlist.includes(key) || allowlist.includes(entry.skill.name);
+}
+export function hasBinary(bin) {
+    const pathEnv = process.env.PATH ?? "";
+    const parts = pathEnv.split(path.delimiter).filter(Boolean);
+    for (const part of parts) {
+        const candidate = path.join(part, bin);
+        try {
+            fs.accessSync(candidate, fs.constants.X_OK);
+            return true;
+        }
+        catch {
+            // keep scanning
+        }
+    }
+    return false;
+}
+function resolveClawdbotMetadata(frontmatter) {
+    const raw = getFrontmatterValue(frontmatter, "metadata");
+    if (!raw)
+        return undefined;
+    try {
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== "object")
+            return undefined;
+        const clawdbot = parsed.clawdbot;
+        if (!clawdbot || typeof clawdbot !== "object")
+            return undefined;
+        const clawdbotObj = clawdbot;
+        const requiresRaw = typeof clawdbotObj.requires === "object" && clawdbotObj.requires !== null
+            ? clawdbotObj.requires
+            : undefined;
+        const installRaw = Array.isArray(clawdbotObj.install)
+            ? clawdbotObj.install
+            : [];
+        const install = installRaw
+            .map((entry) => parseInstallSpec(entry))
+            .filter((entry) => Boolean(entry));
+        const osRaw = normalizeStringList(clawdbotObj.os);
+        return {
+            always: typeof clawdbotObj.always === "boolean"
+                ? clawdbotObj.always
+                : undefined,
+            emoji: typeof clawdbotObj.emoji === "string" ? clawdbotObj.emoji : undefined,
+            homepage: typeof clawdbotObj.homepage === "string"
+                ? clawdbotObj.homepage
+                : undefined,
+            skillKey: typeof clawdbotObj.skillKey === "string"
+                ? clawdbotObj.skillKey
+                : undefined,
+            primaryEnv: typeof clawdbotObj.primaryEnv === "string"
+                ? clawdbotObj.primaryEnv
+                : undefined,
+            os: osRaw.length > 0 ? osRaw : undefined,
+            requires: requiresRaw
+                ? {
+                    bins: normalizeStringList(requiresRaw.bins),
+                    anyBins: normalizeStringList(requiresRaw.anyBins),
+                    env: normalizeStringList(requiresRaw.env),
+                    config: normalizeStringList(requiresRaw.config),
+                }
+                : undefined,
+            install: install.length > 0 ? install : undefined,
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+function resolveSkillKey(skill, entry) {
+    return entry?.clawdbot?.skillKey ?? skill.name;
+}
+function shouldIncludeSkill(params) {
+    const { entry, config } = params;
+    const skillKey = resolveSkillKey(entry.skill, entry);
+    const skillConfig = resolveSkillConfig(config, skillKey);
+    const allowBundled = normalizeAllowlist(config?.skills?.allowBundled);
+    const osList = entry.clawdbot?.os ?? [];
+    if (skillConfig?.enabled === false)
+        return false;
+    if (!isBundledSkillAllowed(entry, allowBundled))
+        return false;
+    if (osList.length > 0 && !osList.includes(resolveRuntimePlatform())) {
+        return false;
+    }
+    if (entry.clawdbot?.always === true) {
+        return true;
+    }
+    const requiredBins = entry.clawdbot?.requires?.bins ?? [];
+    if (requiredBins.length > 0) {
+        for (const bin of requiredBins) {
+            if (!hasBinary(bin))
+                return false;
+        }
+    }
+    const requiredAnyBins = entry.clawdbot?.requires?.anyBins ?? [];
+    if (requiredAnyBins.length > 0) {
+        const anyFound = requiredAnyBins.some((bin) => hasBinary(bin));
+        if (!anyFound)
+            return false;
+    }
+    const requiredEnv = entry.clawdbot?.requires?.env ?? [];
+    if (requiredEnv.length > 0) {
+        for (const envName of requiredEnv) {
+            if (process.env[envName])
+                continue;
+            if (skillConfig?.env?.[envName])
+                continue;
+            if (skillConfig?.apiKey && entry.clawdbot?.primaryEnv === envName) {
+                continue;
+            }
+            return false;
+        }
+    }
+    const requiredConfig = entry.clawdbot?.requires?.config ?? [];
+    if (requiredConfig.length > 0) {
+        for (const configPath of requiredConfig) {
+            if (!isConfigPathTruthy(config, configPath))
+                return false;
+        }
+    }
+    return true;
+}
+function filterSkillEntries(entries, config) {
+    return entries.filter((entry) => shouldIncludeSkill({ entry, config }));
+}
+export function applySkillEnvOverrides(params) {
+    const { skills, config } = params;
+    const updates = [];
+    for (const entry of skills) {
+        const skillKey = resolveSkillKey(entry.skill, entry);
+        const skillConfig = resolveSkillConfig(config, skillKey);
+        if (!skillConfig)
+            continue;
+        if (skillConfig.env) {
+            for (const [envKey, envValue] of Object.entries(skillConfig.env)) {
+                if (!envValue || process.env[envKey])
+                    continue;
+                updates.push({ key: envKey, prev: process.env[envKey] });
+                process.env[envKey] = envValue;
+            }
+        }
+        const primaryEnv = entry.clawdbot?.primaryEnv;
+        if (primaryEnv && skillConfig.apiKey && !process.env[primaryEnv]) {
+            updates.push({ key: primaryEnv, prev: process.env[primaryEnv] });
+            process.env[primaryEnv] = skillConfig.apiKey;
+        }
+    }
+    return () => {
+        for (const update of updates) {
+            if (update.prev === undefined)
+                delete process.env[update.key];
+            else
+                process.env[update.key] = update.prev;
+        }
+    };
+}
+export function applySkillEnvOverridesFromSnapshot(params) {
+    const { snapshot, config } = params;
+    if (!snapshot)
+        return () => { };
+    const updates = [];
+    for (const skill of snapshot.skills) {
+        const skillConfig = resolveSkillConfig(config, skill.name);
+        if (!skillConfig)
+            continue;
+        if (skillConfig.env) {
+            for (const [envKey, envValue] of Object.entries(skillConfig.env)) {
+                if (!envValue || process.env[envKey])
+                    continue;
+                updates.push({ key: envKey, prev: process.env[envKey] });
+                process.env[envKey] = envValue;
+            }
+        }
+        if (skill.primaryEnv &&
+            skillConfig.apiKey &&
+            !process.env[skill.primaryEnv]) {
+            updates.push({
+                key: skill.primaryEnv,
+                prev: process.env[skill.primaryEnv],
+            });
+            process.env[skill.primaryEnv] = skillConfig.apiKey;
+        }
+    }
+    return () => {
+        for (const update of updates) {
+            if (update.prev === undefined)
+                delete process.env[update.key];
+            else
+                process.env[update.key] = update.prev;
+        }
+    };
+}
+function loadSkillEntries(workspaceDir, opts) {
+    const loadSkills = (params) => {
+        const loaded = loadSkillsFromDir(params);
+        if (Array.isArray(loaded))
+            return loaded;
+        if (loaded &&
+            typeof loaded === "object" &&
+            "skills" in loaded &&
+            Array.isArray(loaded.skills)) {
+            return loaded.skills;
+        }
+        return [];
+    };
+    const managedSkillsDir = opts?.managedSkillsDir ?? path.join(CONFIG_DIR, "skills");
+    const workspaceSkillsDir = path.join(workspaceDir, "skills");
+    const bundledSkillsDir = opts?.bundledSkillsDir ?? resolveBundledSkillsDir();
+    const extraDirsRaw = opts?.config?.skills?.load?.extraDirs ?? [];
+    const extraDirs = extraDirsRaw
+        .map((d) => (typeof d === "string" ? d.trim() : ""))
+        .filter(Boolean);
+    const bundledSkills = bundledSkillsDir
+        ? loadSkills({
+            dir: bundledSkillsDir,
+            source: "clawdbot-bundled",
+        })
+        : [];
+    const extraSkills = extraDirs.flatMap((dir) => {
+        const resolved = resolveUserPath(dir);
+        return loadSkills({
+            dir: resolved,
+            source: "clawdbot-extra",
+        });
+    });
+    const managedSkills = loadSkills({
+        dir: managedSkillsDir,
+        source: "clawdbot-managed",
+    });
+    const workspaceSkills = loadSkills({
+        dir: workspaceSkillsDir,
+        source: "clawdbot-workspace",
+    });
+    const merged = new Map();
+    // Precedence: extra < bundled < managed < workspace
+    for (const skill of extraSkills)
+        merged.set(skill.name, skill);
+    for (const skill of bundledSkills)
+        merged.set(skill.name, skill);
+    for (const skill of managedSkills)
+        merged.set(skill.name, skill);
+    for (const skill of workspaceSkills)
+        merged.set(skill.name, skill);
+    const skillEntries = Array.from(merged.values()).map((skill) => {
+        let frontmatter = {};
+        try {
+            const raw = fs.readFileSync(skill.filePath, "utf-8");
+            frontmatter = parseFrontmatter(raw);
+        }
+        catch {
+            // ignore malformed skills
+        }
+        return {
+            skill,
+            frontmatter,
+            clawdbot: resolveClawdbotMetadata(frontmatter),
+        };
+    });
+    return skillEntries;
+}
+export function buildWorkspaceSkillSnapshot(workspaceDir, opts) {
+    const skillEntries = opts?.entries ?? loadSkillEntries(workspaceDir, opts);
+    const eligible = filterSkillEntries(skillEntries, opts?.config);
+    const resolvedSkills = eligible.map((entry) => entry.skill);
+    return {
+        prompt: formatSkillsForPrompt(resolvedSkills),
+        skills: eligible.map((entry) => ({
+            name: entry.skill.name,
+            primaryEnv: entry.clawdbot?.primaryEnv,
+        })),
+        resolvedSkills,
+    };
+}
+export function buildWorkspaceSkillsPrompt(workspaceDir, opts) {
+    const skillEntries = opts?.entries ?? loadSkillEntries(workspaceDir, opts);
+    const eligible = filterSkillEntries(skillEntries, opts?.config);
+    return formatSkillsForPrompt(eligible.map((entry) => entry.skill));
+}
+export function loadWorkspaceSkillEntries(workspaceDir, opts) {
+    return loadSkillEntries(workspaceDir, opts);
+}
+export function filterWorkspaceSkillEntries(entries, config) {
+    return filterSkillEntries(entries, config);
+}
+export function resolveBundledAllowlist(config) {
+    return normalizeAllowlist(config?.skills?.allowBundled);
+}