clawdbot 2026.1.4-1

package/dist/agents/skills-install.js

@@ -0,0 +1,244 @@
+import fs from "node:fs";
+import path from "node:path";
+import { runCommandWithTimeout } from "../process/exec.js";
+import { resolveUserPath } from "../utils.js";
+import { hasBinary, loadWorkspaceSkillEntries, resolveSkillsInstallPreferences, } from "./skills.js";
+function summarizeInstallOutput(text) {
+    const raw = text.trim();
+    if (!raw)
+        return undefined;
+    const lines = raw
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean);
+    if (lines.length === 0)
+        return undefined;
+    const preferred = lines.find((line) => /^error\b/i.test(line)) ??
+        lines.find((line) => /\b(err!|error:|failed)\b/i.test(line)) ??
+        lines.at(-1);
+    if (!preferred)
+        return undefined;
+    const normalized = preferred.replace(/\s+/g, " ").trim();
+    const maxLen = 200;
+    return normalized.length > maxLen
+        ? `${normalized.slice(0, maxLen - 1)}…`
+        : normalized;
+}
+function formatInstallFailureMessage(result) {
+    const code = typeof result.code === "number" ? `exit ${result.code}` : "unknown exit";
+    const summary = summarizeInstallOutput(result.stderr) ??
+        summarizeInstallOutput(result.stdout);
+    if (!summary)
+        return `Install failed (${code})`;
+    return `Install failed (${code}): ${summary}`;
+}
+function resolveInstallId(spec, index) {
+    return (spec.id ?? `${spec.kind}-${index}`).trim();
+}
+function findInstallSpec(entry, installId) {
+    const specs = entry.clawdbot?.install ?? [];
+    for (const [index, spec] of specs.entries()) {
+        if (resolveInstallId(spec, index) === installId)
+            return spec;
+    }
+    return undefined;
+}
+function buildNodeInstallCommand(packageName, prefs) {
+    switch (prefs.nodeManager) {
+        case "pnpm":
+            return ["pnpm", "add", "-g", packageName];
+        case "yarn":
+            return ["yarn", "global", "add", packageName];
+        case "bun":
+            return ["bun", "add", "-g", packageName];
+        default:
+            return ["npm", "install", "-g", packageName];
+    }
+}
+function buildInstallCommand(spec, prefs) {
+    switch (spec.kind) {
+        case "brew": {
+            if (!spec.formula)
+                return { argv: null, error: "missing brew formula" };
+            return { argv: ["brew", "install", spec.formula] };
+        }
+        case "node": {
+            if (!spec.package)
+                return { argv: null, error: "missing node package" };
+            return {
+                argv: buildNodeInstallCommand(spec.package, prefs),
+            };
+        }
+        case "go": {
+            if (!spec.module)
+                return { argv: null, error: "missing go module" };
+            return { argv: ["go", "install", spec.module] };
+        }
+        case "uv": {
+            if (!spec.package)
+                return { argv: null, error: "missing uv package" };
+            return { argv: ["uv", "tool", "install", spec.package] };
+        }
+        default:
+            return { argv: null, error: "unsupported installer" };
+    }
+}
+async function resolveBrewBinDir(timeoutMs) {
+    if (!hasBinary("brew"))
+        return undefined;
+    const prefixResult = await runCommandWithTimeout(["brew", "--prefix"], {
+        timeoutMs: Math.min(timeoutMs, 30_000),
+    });
+    if (prefixResult.code === 0) {
+        const prefix = prefixResult.stdout.trim();
+        if (prefix)
+            return path.join(prefix, "bin");
+    }
+    const envPrefix = process.env.HOMEBREW_PREFIX?.trim();
+    if (envPrefix)
+        return path.join(envPrefix, "bin");
+    for (const candidate of ["/opt/homebrew/bin", "/usr/local/bin"]) {
+        try {
+            if (fs.existsSync(candidate))
+                return candidate;
+        }
+        catch {
+            // ignore
+        }
+    }
+    return undefined;
+}
+export async function installSkill(params) {
+    const timeoutMs = Math.min(Math.max(params.timeoutMs ?? 300_000, 1_000), 900_000);
+    const workspaceDir = resolveUserPath(params.workspaceDir);
+    const entries = loadWorkspaceSkillEntries(workspaceDir);
+    const entry = entries.find((item) => item.skill.name === params.skillName);
+    if (!entry) {
+        return {
+            ok: false,
+            message: `Skill not found: ${params.skillName}`,
+            stdout: "",
+            stderr: "",
+            code: null,
+        };
+    }
+    const spec = findInstallSpec(entry, params.installId);
+    if (!spec) {
+        return {
+            ok: false,
+            message: `Installer not found: ${params.installId}`,
+            stdout: "",
+            stderr: "",
+            code: null,
+        };
+    }
+    const prefs = resolveSkillsInstallPreferences(params.config);
+    const command = buildInstallCommand(spec, prefs);
+    if (command.error) {
+        return {
+            ok: false,
+            message: command.error,
+            stdout: "",
+            stderr: "",
+            code: null,
+        };
+    }
+    if (spec.kind === "brew" && !hasBinary("brew")) {
+        return {
+            ok: false,
+            message: "brew not installed",
+            stdout: "",
+            stderr: "",
+            code: null,
+        };
+    }
+    if (spec.kind === "uv" && !hasBinary("uv")) {
+        if (hasBinary("brew")) {
+            const brewResult = await runCommandWithTimeout(["brew", "install", "uv"], {
+                timeoutMs,
+            });
+            if (brewResult.code !== 0) {
+                return {
+                    ok: false,
+                    message: "Failed to install uv (brew)",
+                    stdout: brewResult.stdout.trim(),
+                    stderr: brewResult.stderr.trim(),
+                    code: brewResult.code,
+                };
+            }
+        }
+        else {
+            return {
+                ok: false,
+                message: "uv not installed (install via brew)",
+                stdout: "",
+                stderr: "",
+                code: null,
+            };
+        }
+    }
+    if (!command.argv || command.argv.length === 0) {
+        return {
+            ok: false,
+            message: "invalid install command",
+            stdout: "",
+            stderr: "",
+            code: null,
+        };
+    }
+    if (spec.kind === "go" && !hasBinary("go")) {
+        if (hasBinary("brew")) {
+            const brewResult = await runCommandWithTimeout(["brew", "install", "go"], {
+                timeoutMs,
+            });
+            if (brewResult.code !== 0) {
+                return {
+                    ok: false,
+                    message: "Failed to install go (brew)",
+                    stdout: brewResult.stdout.trim(),
+                    stderr: brewResult.stderr.trim(),
+                    code: brewResult.code,
+                };
+            }
+        }
+        else {
+            return {
+                ok: false,
+                message: "go not installed (install via brew)",
+                stdout: "",
+                stderr: "",
+                code: null,
+            };
+        }
+    }
+    let env;
+    if (spec.kind === "go" && hasBinary("brew")) {
+        const brewBin = await resolveBrewBinDir(timeoutMs);
+        if (brewBin)
+            env = { GOBIN: brewBin };
+    }
+    const result = await (async () => {
+        const argv = command.argv;
+        if (!argv || argv.length === 0) {
+            return { code: null, stdout: "", stderr: "invalid install command" };
+        }
+        try {
+            return await runCommandWithTimeout(argv, {
+                timeoutMs,
+                env,
+            });
+        }
+        catch (err) {
+            const stderr = err instanceof Error ? err.message : String(err);
+            return { code: null, stdout: "", stderr };
+        }
+    })();
+    const success = result.code === 0;
+    return {
+        ok: success,
+        message: success ? "Installed" : formatInstallFailureMessage(result),
+        stdout: result.stdout.trim(),
+        stderr: result.stderr.trim(),
+        code: result.code,
+    };
+}

package/dist/agents/skills-status.js

@@ -0,0 +1,157 @@
+import path from "node:path";
+import { CONFIG_DIR } from "../utils.js";
+import { hasBinary, isBundledSkillAllowed, isConfigPathTruthy, loadWorkspaceSkillEntries, resolveBundledAllowlist, resolveConfigPath, resolveSkillConfig, resolveSkillsInstallPreferences, } from "./skills.js";
+function resolveSkillKey(entry) {
+    return entry.clawdbot?.skillKey ?? entry.skill.name;
+}
+function selectPreferredInstallSpec(install, prefs) {
+    if (install.length === 0)
+        return undefined;
+    const indexed = install.map((spec, index) => ({ spec, index }));
+    const findKind = (kind) => indexed.find((item) => item.spec.kind === kind);
+    const brewSpec = findKind("brew");
+    const nodeSpec = findKind("node");
+    const goSpec = findKind("go");
+    const uvSpec = findKind("uv");
+    if (prefs.preferBrew && hasBinary("brew") && brewSpec)
+        return brewSpec;
+    if (uvSpec)
+        return uvSpec;
+    if (nodeSpec)
+        return nodeSpec;
+    if (brewSpec)
+        return brewSpec;
+    if (goSpec)
+        return goSpec;
+    return indexed[0];
+}
+function normalizeInstallOptions(entry, prefs) {
+    const install = entry.clawdbot?.install ?? [];
+    if (install.length === 0)
+        return [];
+    const preferred = selectPreferredInstallSpec(install, prefs);
+    if (!preferred)
+        return [];
+    const { spec, index } = preferred;
+    const id = (spec.id ?? `${spec.kind}-${index}`).trim();
+    const bins = spec.bins ?? [];
+    let label = (spec.label ?? "").trim();
+    if (spec.kind === "node" && spec.package) {
+        label = `Install ${spec.package} (${prefs.nodeManager})`;
+    }
+    if (!label) {
+        if (spec.kind === "brew" && spec.formula) {
+            label = `Install ${spec.formula} (brew)`;
+        }
+        else if (spec.kind === "node" && spec.package) {
+            label = `Install ${spec.package} (${prefs.nodeManager})`;
+        }
+        else if (spec.kind === "go" && spec.module) {
+            label = `Install ${spec.module} (go)`;
+        }
+        else if (spec.kind === "uv" && spec.package) {
+            label = `Install ${spec.package} (uv)`;
+        }
+        else {
+            label = "Run installer";
+        }
+    }
+    return [
+        {
+            id,
+            kind: spec.kind,
+            label,
+            bins,
+        },
+    ];
+}
+function buildSkillStatus(entry, config, prefs) {
+    const skillKey = resolveSkillKey(entry);
+    const skillConfig = resolveSkillConfig(config, skillKey);
+    const disabled = skillConfig?.enabled === false;
+    const allowBundled = resolveBundledAllowlist(config);
+    const blockedByAllowlist = !isBundledSkillAllowed(entry, allowBundled);
+    const always = entry.clawdbot?.always === true;
+    const emoji = entry.clawdbot?.emoji ?? entry.frontmatter.emoji;
+    const homepageRaw = entry.clawdbot?.homepage ??
+        entry.frontmatter.homepage ??
+        entry.frontmatter.website ??
+        entry.frontmatter.url;
+    const homepage = homepageRaw?.trim() ? homepageRaw.trim() : undefined;
+    const requiredBins = entry.clawdbot?.requires?.bins ?? [];
+    const requiredEnv = entry.clawdbot?.requires?.env ?? [];
+    const requiredConfig = entry.clawdbot?.requires?.config ?? [];
+    const requiredOs = entry.clawdbot?.os ?? [];
+    const missingBins = requiredBins.filter((bin) => !hasBinary(bin));
+    const missingOs = requiredOs.length > 0 && !requiredOs.includes(process.platform)
+        ? requiredOs
+        : [];
+    const missingEnv = [];
+    for (const envName of requiredEnv) {
+        if (process.env[envName])
+            continue;
+        if (skillConfig?.env?.[envName])
+            continue;
+        if (skillConfig?.apiKey && entry.clawdbot?.primaryEnv === envName) {
+            continue;
+        }
+        missingEnv.push(envName);
+    }
+    const configChecks = requiredConfig.map((pathStr) => {
+        const value = resolveConfigPath(config, pathStr);
+        const satisfied = isConfigPathTruthy(config, pathStr);
+        return { path: pathStr, value, satisfied };
+    });
+    const missingConfig = configChecks
+        .filter((check) => !check.satisfied)
+        .map((check) => check.path);
+    const missing = always
+        ? { bins: [], env: [], config: [], os: [] }
+        : {
+            bins: missingBins,
+            env: missingEnv,
+            config: missingConfig,
+            os: missingOs,
+        };
+    const eligible = !disabled &&
+        !blockedByAllowlist &&
+        (always ||
+            (missing.bins.length === 0 &&
+                missing.env.length === 0 &&
+                missing.config.length === 0 &&
+                missing.os.length === 0));
+    return {
+        name: entry.skill.name,
+        description: entry.skill.description,
+        source: entry.skill.source,
+        filePath: entry.skill.filePath,
+        baseDir: entry.skill.baseDir,
+        skillKey,
+        primaryEnv: entry.clawdbot?.primaryEnv,
+        emoji,
+        homepage,
+        always,
+        disabled,
+        blockedByAllowlist,
+        eligible,
+        requirements: {
+            bins: requiredBins,
+            env: requiredEnv,
+            config: requiredConfig,
+            os: requiredOs,
+        },
+        missing,
+        configChecks,
+        install: normalizeInstallOptions(entry, prefs ?? resolveSkillsInstallPreferences(config)),
+    };
+}
+export function buildWorkspaceSkillStatus(workspaceDir, opts) {
+    const managedSkillsDir = opts?.managedSkillsDir ?? path.join(CONFIG_DIR, "skills");
+    const skillEntries = opts?.entries ?? loadWorkspaceSkillEntries(workspaceDir, opts);
+    const prefs = resolveSkillsInstallPreferences(opts?.config);
+    return {
+        workspaceDir,
+        managedSkillsDir,
+        skills: skillEntries.map((entry) => buildSkillStatus(entry, opts?.config, prefs)),
+    };
+}