@botbotgo/agent-harness 0.0.56 → 0.0.58

package/dist/runtime/skill-requirements.js

@@ -0,0 +1,112 @@
+import path from "node:path";
+import { existsSync } from "node:fs";
+import { augmentExecutablePath } from "./support/runtime-env.js";
+function dedupe(items) {
+    return Array.from(new Set(items.filter(Boolean)));
+}
+function pathEntries(pathValue) {
+    return augmentExecutablePath(pathValue ?? process.env.PATH ?? "")
+        .split(path.delimiter)
+        .map((entry) => entry.trim())
+        .filter(Boolean);
+}
+function isExecutableInPath(binName, searchPath) {
+    for (const entry of pathEntries(searchPath)) {
+        if (existsSync(path.join(entry, binName))) {
+            return true;
+        }
+    }
+    return false;
+}
+function assessNamedRequirements(names, evaluator) {
+    return dedupe(names ?? []).map((name) => ({
+        name,
+        status: evaluator(name),
+    }));
+}
+function hasConfigPath(config, dottedPath) {
+    const parts = dottedPath.split(".").filter(Boolean);
+    let cursor = config;
+    for (const part of parts) {
+        if (typeof cursor !== "object" || cursor === null || Array.isArray(cursor) || !(part in cursor)) {
+            return false;
+        }
+        cursor = cursor[part];
+    }
+    return cursor !== undefined;
+}
+function assessConfigRequirements(names, config) {
+    if (!names || names.length === 0) {
+        return [];
+    }
+    if (!config) {
+        return dedupe(names).map((name) => ({ name, status: "unknown" }));
+    }
+    if (Array.isArray(config)) {
+        const set = new Set(config);
+        return dedupe(names).map((name) => ({
+            name,
+            status: set.has(name) ? "satisfied" : "missing",
+        }));
+    }
+    return dedupe(names).map((name) => ({
+        name,
+        status: hasConfigPath(config, name) ? "satisfied" : "missing",
+    }));
+}
+function summarizeRequirementGroups(groups) {
+    const flat = groups.flat();
+    const missing = flat.some((item) => item.status === "missing");
+    const unknown = flat.some((item) => item.status === "unknown");
+    return {
+        ready: flat.length === 0 ? true : !missing && !unknown,
+        missing,
+        unknown,
+    };
+}
+export function assessOpenClawRequirements(metadata, options = {}) {
+    if (!metadata?.requires) {
+        return undefined;
+    }
+    const availableBins = options.availableBins ? new Set(options.availableBins) : null;
+    const bins = assessNamedRequirements(metadata.requires.bins, (name) => availableBins
+        ? (availableBins.has(name) ? "satisfied" : "missing")
+        : (isExecutableInPath(name, options.path) ? "satisfied" : "missing"));
+    const anyBins = assessNamedRequirements(metadata.requires.anyBins, (name) => availableBins
+        ? (availableBins.has(name) ? "satisfied" : "missing")
+        : (isExecutableInPath(name, options.path) ? "satisfied" : "missing"));
+    const env = assessNamedRequirements(metadata.requires.env, (name) => options.env && options.env[name] ? "satisfied" : "missing");
+    const config = assessConfigRequirements(metadata.requires.config, options.config);
+    const primaryEnv = metadata.requires.primaryEnv
+        ? {
+            name: metadata.requires.primaryEnv,
+            status: (options.env && options.env[metadata.requires.primaryEnv] ? "satisfied" : "missing"),
+        }
+        : undefined;
+    const anyBinsSummary = anyBins.length === 0
+        ? []
+        : [{
+                name: anyBins.map((item) => item.name).join(" | "),
+                status: (anyBins.some((item) => item.status === "satisfied") ? "satisfied" : "missing"),
+            }];
+    const summary = summarizeRequirementGroups([
+        bins,
+        anyBinsSummary,
+        env,
+        config,
+        ...(primaryEnv ? [[primaryEnv]] : []),
+    ]);
+    return {
+        ...summary,
+        bins,
+        anyBins,
+        env,
+        config,
+        ...(primaryEnv ? { primaryEnv } : {}),
+    };
+}
+export function assessSkillRequirements(metadata, options = {}) {
+    return {
+        ...(metadata.openclaw ? { openclaw: assessOpenClawRequirements(metadata.openclaw, options) } : {}),
+    };
+}

package/dist/runtime/support/runtime-env.d.ts

@@ -0,0 +1,2 @@
+export declare function augmentExecutablePath(pathValue: string | undefined, env?: Record<string, string | undefined> | NodeJS.ProcessEnv): string;
+export declare function createRuntimeEnv(env: Record<string, string> | undefined, baseEnv?: Record<string, string | undefined> | NodeJS.ProcessEnv): Record<string, string>;

package/dist/runtime/support/runtime-env.js

@@ -0,0 +1,57 @@
+import { homedir } from "node:os";
+import path from "node:path";
+import { existsSync, readdirSync } from "node:fs";
+const COMMON_EXECUTABLE_DIRS = [
+    "/opt/homebrew/bin",
+    "/opt/homebrew/sbin",
+    "/usr/local/bin",
+    "/usr/local/sbin",
+    "/usr/bin",
+    "/bin",
+    "/usr/sbin",
+    "/sbin",
+];
+function normalizeEnvRecord(env) {
+    return Object.fromEntries(Object.entries(env).filter((entry) => typeof entry[1] === "string"));
+}
+function splitPathEntries(pathValue) {
+    return (pathValue ?? "")
+        .split(path.delimiter)
+        .map((entry) => entry.trim())
+        .filter(Boolean);
+}
+function discoverNvmExecutableDirs(home) {
+    const versionsRoot = path.join(home, ".nvm", "versions", "node");
+    if (!existsSync(versionsRoot)) {
+        return [];
+    }
+    return readdirSync(versionsRoot, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => path.join(versionsRoot, entry.name, "bin"));
+}
+function defaultExecutableDirs(env) {
+    const home = env.HOME ?? env.USERPROFILE ?? homedir();
+    return [
+        ...COMMON_EXECUTABLE_DIRS,
+        path.join(home, ".pyenv", "shims"),
+        path.join(home, ".asdf", "shims"),
+        ...discoverNvmExecutableDirs(home),
+    ];
+}
+export function augmentExecutablePath(pathValue, env = process.env) {
+    const deduped = new Set();
+    for (const entry of [...splitPathEntries(pathValue), ...defaultExecutableDirs(env)]) {
+        deduped.add(entry);
+    }
+    return Array.from(deduped).join(path.delimiter);
+}
+export function createRuntimeEnv(env, baseEnv = process.env) {
+    const base = normalizeEnvRecord(baseEnv);
+    const merged = {
+        ...base,
+        ...(env ?? {}),
+    };
+    const combinedPath = [base.PATH, env?.PATH].filter((value) => typeof value === "string").join(path.delimiter);
+    merged.PATH = augmentExecutablePath(combinedPath, { ...base, ...(env ?? {}) });
+    return merged;
+}

package/dist/runtime/support/skill-metadata.d.ts

@@ -3,8 +3,21 @@ export type SkillMetadata = {
     description?: string;
     license?: string;
     compatibility?: string;
-    metadata?: Record<string, string>;
+    metadata?: Record<string, unknown>;
     allowedTools?: string[];
+    userInvocable?: boolean;
+    openclaw?: OpenClawSkillMetadata;
+};
+export type OpenClawSkillRequirements = {
+    bins?: string[];
+    anyBins?: string[];
+    env?: string[];
+    config?: string[];
+    primaryEnv?: string;
+};
+export type OpenClawSkillMetadata = {
+    emoji?: string;
+    requires?: OpenClawSkillRequirements;
 };
 export declare function readSkillMetadata(skillPath: string): SkillMetadata;
 export declare function validateSkillMetadata(skillPath: string): SkillMetadata;

package/dist/runtime/support/skill-metadata.js

@@ -11,33 +11,81 @@ function parseFrontmatterSource(document) {
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function isJsonLikeValue(value) {
+    if (value === null ||
+        typeof value === "string" ||
+        typeof value === "number" ||
+        typeof value === "boolean") {
+        return true;
+    }
+    if (Array.isArray(value)) {
+        return value.every((item) => isJsonLikeValue(item));
+    }
+    if (isRecord(value)) {
+        return Object.values(value).every((item) => isJsonLikeValue(item));
+    }
+    return false;
+}
 function normalizeMetadata(value, strict) {
     if (value === undefined) {
         return undefined;
     }
     if (!isRecord(value)) {
         if (strict) {
-            throw new Error("metadata must be a string key-value map");
+            throw new Error("metadata must be a JSON-like key-value map");
         }
         return undefined;
     }
     const normalized = Object.entries(value).reduce((acc, [key, item]) => {
-        if (typeof item === "string") {
+        if (isJsonLikeValue(item)) {
             acc[key] = item;
         }
         return acc;
     }, {});
     if (strict && Object.keys(normalized).length !== Object.keys(value).length) {
-        throw new Error("metadata values must all be strings");
+        throw new Error("metadata values must be JSON-like");
     }
     return Object.keys(normalized).length > 0 ? normalized : undefined;
 }
+function normalizeStringArray(value) {
+    if (typeof value === "string") {
+        const tokens = value.split(/\s+/).filter(Boolean);
+        return tokens.length > 0 ? tokens : undefined;
+    }
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    const tokens = value
+        .filter((item) => typeof item === "string")
+        .map((item) => item.trim())
+        .filter(Boolean);
+    return tokens.length > 0 ? tokens : undefined;
+}
 function toAllowedTools(value) {
-    if (typeof value !== "string") {
+    const tools = normalizeStringArray(value);
+    return tools && tools.length > 0 ? tools : undefined;
+}
+function parseOpenClawMetadata(value) {
+    if (!isRecord(value)) {
         return undefined;
     }
-    const tools = value.split(/\s+/).filter(Boolean);
-    return tools.length > 0 ? tools : undefined;
+    const requires = isRecord(value.requires) ? value.requires : undefined;
+    const normalizedRequires = {
+        ...(normalizeStringArray(requires?.bins) ? { bins: normalizeStringArray(requires?.bins) } : {}),
+        ...(normalizeStringArray(requires?.anyBins) ? { anyBins: normalizeStringArray(requires?.anyBins) } : {}),
+        ...(normalizeStringArray(requires?.env) ? { env: normalizeStringArray(requires?.env) } : {}),
+        ...(normalizeStringArray(requires?.config) ? { config: normalizeStringArray(requires?.config) } : {}),
+        ...(typeof value.primaryEnv === "string" && value.primaryEnv.trim()
+            ? { primaryEnv: value.primaryEnv.trim() }
+            : typeof requires?.primaryEnv === "string" && requires.primaryEnv.trim()
+                ? { primaryEnv: requires.primaryEnv.trim() }
+                : {}),
+    };
+    const normalized = {
+        ...(typeof value.emoji === "string" && value.emoji.trim() ? { emoji: value.emoji } : {}),
+        ...(Object.keys(normalizedRequires).length > 0 ? { requires: normalizedRequires } : {}),
+    };
+    return Object.keys(normalized).length > 0 ? normalized : undefined;
 }
 function parseFrontmatter(document, strict = false) {
     const source = parseFrontmatterSource(document);
@@ -55,6 +103,8 @@ function parseFrontmatter(document, strict = false) {
         compatibility: typeof parsed.compatibility === "string" ? parsed.compatibility : undefined,
         metadata: normalizeMetadata(parsed.metadata, strict),
         allowedTools: toAllowedTools(parsed["allowed-tools"]),
+        userInvocable: typeof parsed["user-invocable"] === "boolean" ? parsed["user-invocable"] : undefined,
+        openclaw: parseOpenClawMetadata(isRecord(parsed.metadata) ? parsed.metadata.openclaw : undefined),
     };
 }
 function isLegacyBuiltinSkillName(name) {
@@ -86,7 +136,7 @@ function validateMetadata(metadata, skillPath) {
         return;
     }
     if (Object.keys(metadata).length === 0) {
-        throw new Error(`Skill ${skillPath} metadata must contain string key-value pairs when provided`);
+        throw new Error(`Skill ${skillPath} metadata must contain JSON-like key-value pairs when provided`);
     }
 }
 function parseSkillMetadataFromDocument(document, skillPath, strict) {
@@ -104,6 +154,8 @@ function parseSkillMetadataFromDocument(document, skillPath, strict) {
         compatibility: parsed.compatibility,
         metadata: parsed.metadata,
         allowedTools: parsed.allowedTools,
+        userInvocable: parsed.userInvocable,
+        openclaw: parsed.openclaw,
     };
     if (strict) {
         validateSkillName(metadata.name, skillPath);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botbotgo/agent-harness",
-  "version": "0.0.56",
+  "version": "0.0.58",
   "description": "Workspace runtime for multi-agent applications",
   "type": "module",
   "packageManager": "npm@10.9.2",
@@ -50,7 +50,7 @@
   "scripts": {
     "build": "rm -rf dist tsconfig.tsbuildinfo && tsc -p tsconfig.json && cp -R config dist/",
     "check": "tsc -p tsconfig.json --noEmit",
-    "test": "vitest run test/public-api.test.ts test/resource-optional-provider.test.ts test/resource-isolation.test.ts test/stock-research-app-load-harness.test.ts test/stock-research-app-run.test.ts test/stock-research-app-config.test.ts test/release-workflow.test.ts test/release-version.test.ts test/gitignore.test.ts test/package-lock.test.ts test/readme.test.ts test/product-boundary-docs.test.ts test/runtime-adapter-regressions.test.ts test/runtime-capabilities.test.ts test/runtime-recovery.test.ts test/tool-extension-gaps.test.ts test/checkpoint-maintenance.test.ts test/llamaindex-dependency-compat.test.ts test/skill-standard.test.ts test/routing-config.test.ts test/workspace-compat-regressions.test.ts test/upstream-compat-regressions.test.ts test/yaml-format.test.ts",
+    "test": "vitest run test/hello-file.test.ts test/public-api.test.ts test/resource-optional-provider.test.ts test/resource-isolation.test.ts test/stock-research-app-load-harness.test.ts test/stock-research-app-run.test.ts test/stock-research-app-config.test.ts test/release-workflow.test.ts test/release-version.test.ts test/gitignore.test.ts test/package-lock.test.ts test/readme.test.ts test/product-boundary-docs.test.ts test/docs-site.test.ts test/runtime-adapter-regressions.test.ts test/runtime-capabilities.test.ts test/runtime-recovery.test.ts test/tool-extension-gaps.test.ts test/checkpoint-maintenance.test.ts test/llamaindex-dependency-compat.test.ts test/skill-standard.test.ts test/routing-config.test.ts test/workspace-compat-regressions.test.ts test/upstream-compat-regressions.test.ts test/yaml-format.test.ts",
     "test:real-providers": "vitest run test/real-provider-harness.test.ts",
     "release:prepare": "npm version patch --no-git-tag-version && node ./scripts/sync-example-version.mjs",
     "release:pack": "npm pack --dry-run",