agiagent-dev 2026.1.30

package/dist/agents/skills-install.js

@@ -0,0 +1,410 @@
+import fs from "node:fs";
+import path from "node:path";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { resolveBrewExecutable } from "../infra/brew.js";
+import { runCommandWithTimeout } from "../process/exec.js";
+import { CONFIG_DIR, ensureDir, resolveUserPath } from "../utils.js";
+import { hasBinary, loadWorkspaceSkillEntries, resolveSkillsInstallPreferences, } from "./skills.js";
+import { resolveSkillKey } from "./skills/frontmatter.js";
+function isNodeReadableStream(value) {
+    return Boolean(value && typeof value.pipe === "function");
+}
+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.metadata?.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] };
+        }
+        case "download": {
+            return { argv: null, error: "download install handled separately" };
+        }
+        default:
+            return { argv: null, error: "unsupported installer" };
+    }
+}
+function resolveDownloadTargetDir(entry, spec) {
+    if (spec.targetDir?.trim()) {
+        return resolveUserPath(spec.targetDir);
+    }
+    const key = resolveSkillKey(entry.skill, entry);
+    return path.join(CONFIG_DIR, "tools", key);
+}
+function resolveArchiveType(spec, filename) {
+    const explicit = spec.archive?.trim().toLowerCase();
+    if (explicit) {
+        return explicit;
+    }
+    const lower = filename.toLowerCase();
+    if (lower.endsWith(".tar.gz") || lower.endsWith(".tgz")) {
+        return "tar.gz";
+    }
+    if (lower.endsWith(".tar.bz2") || lower.endsWith(".tbz2")) {
+        return "tar.bz2";
+    }
+    if (lower.endsWith(".zip")) {
+        return "zip";
+    }
+    return undefined;
+}
+async function downloadFile(url, destPath, timeoutMs) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), Math.max(1_000, timeoutMs));
+    try {
+        const response = await fetch(url, { signal: controller.signal });
+        if (!response.ok || !response.body) {
+            throw new Error(`Download failed (${response.status} ${response.statusText})`);
+        }
+        await ensureDir(path.dirname(destPath));
+        const file = fs.createWriteStream(destPath);
+        const body = response.body;
+        const readable = isNodeReadableStream(body)
+            ? body
+            : Readable.fromWeb(body);
+        await pipeline(readable, file);
+        const stat = await fs.promises.stat(destPath);
+        return { bytes: stat.size };
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+async function extractArchive(params) {
+    const { archivePath, archiveType, targetDir, stripComponents, timeoutMs } = params;
+    if (archiveType === "zip") {
+        if (!hasBinary("unzip")) {
+            return { stdout: "", stderr: "unzip not found on PATH", code: null };
+        }
+        const argv = ["unzip", "-q", archivePath, "-d", targetDir];
+        return await runCommandWithTimeout(argv, { timeoutMs });
+    }
+    if (!hasBinary("tar")) {
+        return { stdout: "", stderr: "tar not found on PATH", code: null };
+    }
+    const argv = ["tar", "xf", archivePath, "-C", targetDir];
+    if (typeof stripComponents === "number" && Number.isFinite(stripComponents)) {
+        argv.push("--strip-components", String(Math.max(0, Math.floor(stripComponents))));
+    }
+    return await runCommandWithTimeout(argv, { timeoutMs });
+}
+async function installDownloadSpec(params) {
+    const { entry, spec, timeoutMs } = params;
+    const url = spec.url?.trim();
+    if (!url) {
+        return {
+            ok: false,
+            message: "missing download url",
+            stdout: "",
+            stderr: "",
+            code: null,
+        };
+    }
+    let filename = "";
+    try {
+        const parsed = new URL(url);
+        filename = path.basename(parsed.pathname);
+    }
+    catch {
+        filename = path.basename(url);
+    }
+    if (!filename) {
+        filename = "download";
+    }
+    const targetDir = resolveDownloadTargetDir(entry, spec);
+    await ensureDir(targetDir);
+    const archivePath = path.join(targetDir, filename);
+    let downloaded = 0;
+    try {
+        const result = await downloadFile(url, archivePath, timeoutMs);
+        downloaded = result.bytes;
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { ok: false, message, stdout: "", stderr: message, code: null };
+    }
+    const archiveType = resolveArchiveType(spec, filename);
+    const shouldExtract = spec.extract ?? Boolean(archiveType);
+    if (!shouldExtract) {
+        return {
+            ok: true,
+            message: `Downloaded to ${archivePath}`,
+            stdout: `downloaded=${downloaded}`,
+            stderr: "",
+            code: 0,
+        };
+    }
+    if (!archiveType) {
+        return {
+            ok: false,
+            message: "extract requested but archive type could not be detected",
+            stdout: "",
+            stderr: "",
+            code: null,
+        };
+    }
+    const extractResult = await extractArchive({
+        archivePath,
+        archiveType,
+        targetDir,
+        stripComponents: spec.stripComponents,
+        timeoutMs,
+    });
+    const success = extractResult.code === 0;
+    return {
+        ok: success,
+        message: success
+            ? `Downloaded and extracted to ${targetDir}`
+            : formatInstallFailureMessage(extractResult),
+        stdout: extractResult.stdout.trim(),
+        stderr: extractResult.stderr.trim(),
+        code: extractResult.code,
+    };
+}
+async function resolveBrewBinDir(timeoutMs, brewExe) {
+    const exe = brewExe ?? (hasBinary("brew") ? "brew" : resolveBrewExecutable());
+    if (!exe) {
+        return undefined;
+    }
+    const prefixResult = await runCommandWithTimeout([exe, "--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,
+        };
+    }
+    if (spec.kind === "download") {
+        return await installDownloadSpec({ entry, spec, timeoutMs });
+    }
+    const prefs = resolveSkillsInstallPreferences(params.config);
+    const command = buildInstallCommand(spec, prefs);
+    if (command.error) {
+        return {
+            ok: false,
+            message: command.error,
+            stdout: "",
+            stderr: "",
+            code: null,
+        };
+    }
+    const brewExe = hasBinary("brew") ? "brew" : resolveBrewExecutable();
+    if (spec.kind === "brew" && !brewExe) {
+        return {
+            ok: false,
+            message: "brew not installed",
+            stdout: "",
+            stderr: "",
+            code: null,
+        };
+    }
+    if (spec.kind === "uv" && !hasBinary("uv")) {
+        if (brewExe) {
+            const brewResult = await runCommandWithTimeout([brewExe, "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 === "brew" && brewExe && command.argv[0] === "brew") {
+        command.argv[0] = brewExe;
+    }
+    if (spec.kind === "go" && !hasBinary("go")) {
+        if (brewExe) {
+            const brewResult = await runCommandWithTimeout([brewExe, "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" && brewExe) {
+        const brewBin = await resolveBrewBinDir(timeoutMs, brewExe);
+        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.d.ts

@@ -0,0 +1,55 @@
+import type { AGIAgentConfig } from "../config/config.js";
+import { type SkillEntry, type SkillEligibilityContext, type SkillInstallSpec } from "./skills.js";
+export type SkillStatusConfigCheck = {
+    path: string;
+    value: unknown;
+    satisfied: boolean;
+};
+export type SkillInstallOption = {
+    id: string;
+    kind: SkillInstallSpec["kind"];
+    label: string;
+    bins: string[];
+};
+export type SkillStatusEntry = {
+    name: string;
+    description: string;
+    source: string;
+    filePath: string;
+    baseDir: string;
+    skillKey: string;
+    primaryEnv?: string;
+    emoji?: string;
+    homepage?: string;
+    always: boolean;
+    disabled: boolean;
+    blockedByAllowlist: boolean;
+    eligible: boolean;
+    requirements: {
+        bins: string[];
+        anyBins: string[];
+        env: string[];
+        config: string[];
+        os: string[];
+    };
+    missing: {
+        bins: string[];
+        anyBins: string[];
+        env: string[];
+        config: string[];
+        os: string[];
+    };
+    configChecks: SkillStatusConfigCheck[];
+    install: SkillInstallOption[];
+};
+export type SkillStatusReport = {
+    workspaceDir: string;
+    managedSkillsDir: string;
+    skills: SkillStatusEntry[];
+};
+export declare function buildWorkspaceSkillStatus(workspaceDir: string, opts?: {
+    config?: AGIAgentConfig;
+    managedSkillsDir?: string;
+    entries?: SkillEntry[];
+    eligibility?: SkillEligibilityContext;
+}): SkillStatusReport;

package/dist/agents/skills-status.js

@@ -0,0 +1,196 @@
+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.metadata?.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.metadata?.install ?? [];
+    if (install.length === 0) {
+        return [];
+    }
+    const platform = process.platform;
+    const filtered = install.filter((spec) => {
+        const osList = spec.os ?? [];
+        return osList.length === 0 || osList.includes(platform);
+    });
+    if (filtered.length === 0) {
+        return [];
+    }
+    const toOption = (spec, index) => {
+        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 if (spec.kind === "download" && spec.url) {
+                const url = spec.url.trim();
+                const last = url.split("/").pop();
+                label = `Download ${last && last.length > 0 ? last : url}`;
+            }
+            else {
+                label = "Run installer";
+            }
+        }
+        return { id, kind: spec.kind, label, bins };
+    };
+    const allDownloads = filtered.every((spec) => spec.kind === "download");
+    if (allDownloads) {
+        return filtered.map((spec, index) => toOption(spec, index));
+    }
+    const preferred = selectPreferredInstallSpec(filtered, prefs);
+    if (!preferred) {
+        return [];
+    }
+    return [toOption(preferred.spec, preferred.index)];
+}
+function buildSkillStatus(entry, config, prefs, eligibility) {
+    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.metadata?.always === true;
+    const emoji = entry.metadata?.emoji ?? entry.frontmatter.emoji;
+    const homepageRaw = entry.metadata?.homepage ??
+        entry.frontmatter.homepage ??
+        entry.frontmatter.website ??
+        entry.frontmatter.url;
+    const homepage = homepageRaw?.trim() ? homepageRaw.trim() : undefined;
+    const requiredBins = entry.metadata?.requires?.bins ?? [];
+    const requiredAnyBins = entry.metadata?.requires?.anyBins ?? [];
+    const requiredEnv = entry.metadata?.requires?.env ?? [];
+    const requiredConfig = entry.metadata?.requires?.config ?? [];
+    const requiredOs = entry.metadata?.os ?? [];
+    const missingBins = requiredBins.filter((bin) => {
+        if (hasBinary(bin)) {
+            return false;
+        }
+        if (eligibility?.remote?.hasBin?.(bin)) {
+            return false;
+        }
+        return true;
+    });
+    const missingAnyBins = requiredAnyBins.length > 0 &&
+        !(requiredAnyBins.some((bin) => hasBinary(bin)) ||
+            eligibility?.remote?.hasAnyBin?.(requiredAnyBins))
+        ? requiredAnyBins
+        : [];
+    const missingOs = requiredOs.length > 0 &&
+        !requiredOs.includes(process.platform) &&
+        !eligibility?.remote?.platforms?.some((platform) => requiredOs.includes(platform))
+        ? requiredOs
+        : [];
+    const missingEnv = [];
+    for (const envName of requiredEnv) {
+        if (process.env[envName]) {
+            continue;
+        }
+        if (skillConfig?.env?.[envName]) {
+            continue;
+        }
+        if (skillConfig?.apiKey && entry.metadata?.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: [], anyBins: [], env: [], config: [], os: [] }
+        : {
+            bins: missingBins,
+            anyBins: missingAnyBins,
+            env: missingEnv,
+            config: missingConfig,
+            os: missingOs,
+        };
+    const eligible = !disabled &&
+        !blockedByAllowlist &&
+        (always ||
+            (missing.bins.length === 0 &&
+                missing.anyBins.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.metadata?.primaryEnv,
+        emoji,
+        homepage,
+        always,
+        disabled,
+        blockedByAllowlist,
+        eligible,
+        requirements: {
+            bins: requiredBins,
+            anyBins: requiredAnyBins,
+            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, opts?.eligibility)),
+    };
+}

package/dist/agents/skills.d.ts

@@ -0,0 +1,7 @@
+import type { AGIAgentConfig } from "../config/config.js";
+import type { SkillsInstallPreferences } from "./skills/types.js";
+export { hasBinary, isBundledSkillAllowed, isConfigPathTruthy, resolveBundledAllowlist, resolveConfigPath, resolveRuntimePlatform, resolveSkillConfig, } from "./skills/config.js";
+export { applySkillEnvOverrides, applySkillEnvOverridesFromSnapshot, } from "./skills/env-overrides.js";
+export type { AGIAgentSkillMetadata, SkillEligibilityContext, SkillCommandSpec, SkillEntry, SkillInstallSpec, SkillSnapshot, SkillsInstallPreferences, } from "./skills/types.js";
+export { buildWorkspaceSkillSnapshot, buildWorkspaceSkillsPrompt, buildWorkspaceSkillCommandSpecs, filterWorkspaceSkillEntries, loadWorkspaceSkillEntries, resolveSkillsPromptForRun, syncSkillsToWorkspace, } from "./skills/workspace.js";
+export declare function resolveSkillsInstallPreferences(config?: AGIAgentConfig): SkillsInstallPreferences;

package/dist/agents/skills.js

@@ -0,0 +1,13 @@
+export { hasBinary, isBundledSkillAllowed, isConfigPathTruthy, resolveBundledAllowlist, resolveConfigPath, resolveRuntimePlatform, resolveSkillConfig, } from "./skills/config.js";
+export { applySkillEnvOverrides, applySkillEnvOverridesFromSnapshot, } from "./skills/env-overrides.js";
+export { buildWorkspaceSkillSnapshot, buildWorkspaceSkillsPrompt, buildWorkspaceSkillCommandSpecs, filterWorkspaceSkillEntries, loadWorkspaceSkillEntries, resolveSkillsPromptForRun, syncSkillsToWorkspace, } from "./skills/workspace.js";
+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 };
+}