@qvac/harness 0.1.0 → 0.1.2

package/dist-lib/lib/tools/skills/credential-check.d.ts

@@ -0,0 +1,20 @@
+import type { AbortSignal as BareAbortSignal } from 'bare-abort-controller';
+import { type CredentialStoreFn } from './auth-resolver.ts';
+import type { SkillCatalogEntry } from './catalog.ts';
+export declare const CREDENTIAL_CHECK_TTL_MS = 45000;
+type CredentialCheckResponse = {
+    readonly status: number;
+    text?: () => Promise<string>;
+};
+export type CredentialCheckFetch = (input: string, init: {
+    method: string;
+    headers: Headers;
+    signal: BareAbortSignal;
+}) => Promise<CredentialCheckResponse>;
+export interface ValidateCredentialChecksOptions {
+    refresh?: boolean | undefined;
+    now?: () => number;
+    ttlMs?: number;
+}
+export declare function validateCredentialChecks(catalog: readonly SkillCatalogEntry[], credentialStore: CredentialStoreFn | undefined, agentId?: string | null, fetchImpl?: CredentialCheckFetch, { refresh, now, ttlMs }?: ValidateCredentialChecksOptions): Promise<void>;
+export {};

package/dist-lib/lib/tools/skills/credential-check.js

@@ -0,0 +1,94 @@
+import fetch from '#fetch';
+import { Headers } from '#headers';
+import { AbortController } from 'bare-abort-controller';
+import { DEFAULT_USER_AGENT } from "../../user-agent.js";
+import { credentialRecord, isCredentialUrlAllowed } from "./auth-resolver.js";
+import { credentialLastProbedAt, markCredentialRejected, markCredentialValid, setCredentialLastProbedAt } from "./credential-health.js";
+const TIMEOUT_MS = 5_000;
+export const CREDENTIAL_CHECK_TTL_MS = 45_000;
+const inflight = new Map();
+function scopedKey(key, agentId) {
+    return agentId ? `${agentId}\0${key}` : key;
+}
+export async function validateCredentialChecks(catalog, credentialStore, agentId, fetchImpl, { refresh = false, now = Date.now, ttlMs = CREDENTIAL_CHECK_TTL_MS } = {}) {
+    if (!credentialStore)
+        return;
+    const doFetch = fetchImpl ?? fetch;
+    const checks = new Map();
+    for (const skill of catalog) {
+        for (const [key, check] of Object.entries(skill.requires?.credentialChecks ?? {})) {
+            if (!isCredentialUrlAllowed(check.url, skill.allowList))
+                continue;
+            if (!checks.has(key))
+                checks.set(key, { check, skill: skill.name });
+        }
+    }
+    const at = now();
+    await Promise.all([...checks].map(async ([key, { check, skill }]) => {
+        if (!refresh) {
+            const last = credentialLastProbedAt(key, agentId);
+            if (last !== undefined && at - last < ttlMs)
+                return;
+        }
+        const sk = scopedKey(key, agentId);
+        const pending = inflight.get(sk);
+        if (pending) {
+            await pending;
+            return;
+        }
+        const probe = runCheck(key, check, skill, credentialStore, agentId, doFetch).finally(() => {
+            inflight.delete(sk);
+        });
+        inflight.set(sk, probe);
+        await probe;
+        setCredentialLastProbedAt(key, now(), agentId);
+    }));
+}
+async function runCheck(key, check, skill, credentialStore, agentId, fetchImpl) {
+    const record = credentialRecord(await credentialStore(key, { agentId, skills: [skill] }));
+    if (!record)
+        return;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort('credential check timed out'), TIMEOUT_MS);
+    try {
+        const headers = new Headers({ ...(check.headers ?? {}) });
+        if (!headers.has('user-agent')) {
+            headers.set('user-agent', DEFAULT_USER_AGENT);
+        }
+        headers.set('Authorization', `Bearer ${record.token}`);
+        const response = await fetchImpl(check.url, {
+            method: check.method ?? 'GET',
+            headers: headers,
+            signal: controller.signal
+        });
+        const rejected = response.status === 401 || response.status === 403 || (await hasMcpAuthError(response));
+        if (rejected) {
+            markCredentialRejected(key, agentId);
+        }
+        else if (response.status >= 200 && response.status < 300) {
+            markCredentialValid(key, agentId);
+        }
+    }
+    catch {
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+async function hasMcpAuthError(response) {
+    if (response.status < 200 || response.status >= 300 || !response.text)
+        return false;
+    try {
+        const body = JSON.parse(await response.text());
+        const error = body.error;
+        if (!error)
+            return false;
+        if (error.code === 401 || error.code === 403)
+            return true;
+        return (typeof error.message === 'string' &&
+            /unauthori[sz]ed|forbidden|token.*expired/i.test(error.message));
+    }
+    catch {
+        return false;
+    }
+}

package/dist-lib/lib/tools/skills/credential-grants.d.ts

@@ -0,0 +1,9 @@
+import type { CredentialAllowList, CredentialAllowListFn } from './auth-resolver.ts';
+import { type CredentialSlotSource } from './credential-slots.ts';
+export interface CredentialGrantEntry extends CredentialSlotSource {
+    readonly name: string;
+    readonly allowList: readonly string[];
+    readonly origin?: 'overlay';
+}
+export declare function credentialGrants(catalog: readonly CredentialGrantEntry[], skills: readonly string[] | undefined): CredentialAllowList;
+export declare function credentialAllowListFor(catalog: readonly CredentialGrantEntry[]): CredentialAllowListFn;

package/dist-lib/lib/tools/skills/credential-grants.js

@@ -0,0 +1,25 @@
+import { credentialSlots } from "./credential-slots.js";
+export function credentialGrants(catalog, skills) {
+    if (!skills || skills.length === 0)
+        return {};
+    const loaded = new Set(skills);
+    const map = {};
+    for (const entry of catalog) {
+        if (entry.origin === 'overlay')
+            continue;
+        if (!loaded.has(entry.name) || entry.allowList.length === 0)
+            continue;
+        for (const key of credentialSlots(entry).flat()) {
+            const list = map[key] ?? [];
+            for (const host of entry.allowList) {
+                if (!list.includes(host))
+                    list.push(host);
+            }
+            map[key] = list;
+        }
+    }
+    return map;
+}
+export function credentialAllowListFor(catalog) {
+    return (ctx) => credentialGrants(catalog, ctx?.skills);
+}

package/dist-lib/lib/tools/skills/credential-health.d.ts

@@ -0,0 +1,8 @@
+export declare function markCredentialRejected(key: string, agentId?: string | null, skill?: string | null): void;
+export declare function markCredentialValid(key: string, agentId?: string | null, skill?: string | null): void;
+export declare function recordCredentialHealth(key: string, status: number, agentId?: string | null): void;
+export declare function isCredentialRejected(key: string, agentId?: string | null, skill?: string | null): boolean;
+export declare function credentialLastProbedAt(key: string, agentId?: string | null, skill?: string | null): number | undefined;
+export declare function setCredentialLastProbedAt(key: string, at: number, agentId?: string | null, skill?: string | null): void;
+export declare function resetCredentialHealth(key: string, agentId?: string | null, skill?: string | null): void;
+export declare function resetAllCredentialHealth(): void;

package/dist-lib/lib/tools/skills/credential-health.js

@@ -0,0 +1,51 @@
+import { hlog } from "../../log.js";
+import { scopeKey } from "./scope-key.js";
+const rejected = new Set();
+const lastProbedAt = new Map();
+function scopedKey(key, agentId, skill) {
+    return scopeKey({ agentId, skill, key });
+}
+export function markCredentialRejected(key, agentId, skill) {
+    rejected.add(scopedKey(key, agentId, skill));
+}
+export function markCredentialValid(key, agentId, skill) {
+    rejected.delete(scopedKey(key, agentId, skill));
+    if (skill)
+        rejected.delete(scopedKey(key, agentId));
+}
+export function recordCredentialHealth(key, status, agentId) {
+    if (status === 401 || status === 403) {
+        hlog('credential rejected by provider', { key, status });
+        markCredentialRejected(key, agentId);
+    }
+    else if (status < 400) {
+        if (isCredentialRejected(key, agentId))
+            hlog('credential recovered', { key });
+        markCredentialValid(key, agentId);
+    }
+}
+export function isCredentialRejected(key, agentId, skill) {
+    if (rejected.has(scopedKey(key, agentId)))
+        return true;
+    return skill ? rejected.has(scopedKey(key, agentId, skill)) : false;
+}
+export function credentialLastProbedAt(key, agentId, skill) {
+    return lastProbedAt.get(scopedKey(key, agentId, skill));
+}
+export function setCredentialLastProbedAt(key, at, agentId, skill) {
+    lastProbedAt.set(scopedKey(key, agentId, skill), at);
+}
+export function resetCredentialHealth(key, agentId, skill) {
+    const sk = scopedKey(key, agentId, skill);
+    rejected.delete(sk);
+    lastProbedAt.delete(sk);
+    if (skill) {
+        const shared = scopedKey(key, agentId);
+        rejected.delete(shared);
+        lastProbedAt.delete(shared);
+    }
+}
+export function resetAllCredentialHealth() {
+    rejected.clear();
+    lastProbedAt.clear();
+}

package/dist-lib/lib/tools/skills/credential-slots.d.ts

@@ -0,0 +1,7 @@
+export interface CredentialSlotSource {
+    readonly credentials?: readonly string[] | undefined;
+    readonly requires?: {
+        readonly credentials?: readonly string[] | undefined;
+    } | undefined;
+}
+export declare function credentialSlots(entry: CredentialSlotSource): readonly (readonly string[])[];

package/dist-lib/lib/tools/skills/credential-slots.js

@@ -0,0 +1,8 @@
+export function credentialSlots(entry) {
+    return [...new Set([...(entry.credentials ?? []), ...(entry.requires?.credentials ?? [])])]
+        .map((raw) => raw
+        .split('|')
+        .map((key) => key.trim())
+        .filter(Boolean))
+        .filter((alts) => alts.length > 0);
+}

package/dist-lib/lib/tools/skills/frontmatter-parser.d.ts

@@ -0,0 +1,23 @@
+import type { InstallStep, SkillRequires, SkillSetup } from './manifest.ts';
+export interface SkillFrontMatter {
+    name?: string;
+    description?: string;
+    aliases?: string[];
+    preloadOnName?: boolean;
+    tools?: string[];
+    platform?: string[];
+    credentials?: string[];
+    allowList?: string[];
+    mcpReads?: string[];
+    requires?: SkillRequires;
+    install?: InstallStep[];
+    setup?: SkillSetup;
+    stub?: boolean;
+    minCapabilityProfile?: string;
+    emoji?: string;
+}
+export interface ParsedSkill {
+    meta: SkillFrontMatter;
+    body: string;
+}
+export declare function parseSkillFrontMatter(raw: string): ParsedSkill;

package/dist-lib/lib/tools/skills/frontmatter-parser.js

@@ -0,0 +1,68 @@
+import { parseManifestBlock } from "./manifest-parse.js";
+const FRONT_MATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
+const FIELD_RE = /^([A-Za-z_][\w-]*):(.*)$/;
+const LIST_FIELDS = new Set(['tools', 'platform', 'credentials', 'allow_list', 'aliases']);
+export function parseSkillFrontMatter(raw) {
+    try {
+        const match = FRONT_MATTER_RE.exec(raw);
+        if (!match)
+            return { meta: {}, body: raw };
+        const block = match[1] ?? '';
+        const meta = { ...parseFields(block), ...parseManifestBlock(block) };
+        return { meta, body: (match[2] ?? '').trim() };
+    }
+    catch {
+        return { meta: {}, body: raw };
+    }
+}
+function unwrap(lines) {
+    const out = [];
+    for (const line of lines) {
+        if (out.length > 0 && /^\s/.test(line) && line.trim().length > 0) {
+            out[out.length - 1] += ` ${line.trim()}`;
+        }
+        else {
+            out.push(line);
+        }
+    }
+    return out;
+}
+function parseFields(block) {
+    const meta = {};
+    for (const line of unwrap(block.split(/\r?\n/))) {
+        const field = FIELD_RE.exec(line);
+        if (!field)
+            continue;
+        const key = field[1] ?? '';
+        const value = (field[2] ?? '').trim();
+        if (!value)
+            continue;
+        if (key === 'allow_list') {
+            meta.allowList = parseList(value);
+        }
+        else if (key === 'mcp_reads') {
+            meta.mcpReads = parseList(value);
+        }
+        else if (LIST_FIELDS.has(key)) {
+            meta[key] = parseList(value);
+        }
+        else if (key === 'name' || key === 'description') {
+            meta[key] = stripQuotes(value);
+        }
+        else if (key === 'preload_on_name') {
+            meta.preloadOnName = stripQuotes(value).toLowerCase() !== 'false';
+        }
+    }
+    return meta;
+}
+function parseList(value) {
+    const inline = /^\[(.*)\]$/.exec(value);
+    const items = inline ? (inline[1] ?? '') : value.replace(/(^|\s)-\s+/g, ',');
+    return items
+        .split(',')
+        .map((item) => stripQuotes(item.trim()))
+        .filter((item) => item.length > 0);
+}
+function stripQuotes(value) {
+    return value.replace(/^["']|["']$/g, '');
+}

package/dist-lib/lib/tools/skills/index.d.ts

@@ -0,0 +1,5 @@
+export * from './auth-resolver.ts';
+export * from './catalog.ts';
+export * from './cli-schema.ts';
+export * from './credential-grants.ts';
+export * from './frontmatter-parser.ts';

package/dist-lib/lib/tools/skills/index.js

@@ -0,0 +1,5 @@
+export * from "./auth-resolver.js";
+export * from "./catalog.js";
+export * from "./cli-schema.js";
+export * from "./credential-grants.js";
+export * from "./frontmatter-parser.js";

package/dist-lib/lib/tools/skills/manifest-parse.d.ts

@@ -0,0 +1,12 @@
+import type { InstallStep, SkillRequires, SkillSetup } from './manifest.ts';
+export interface ParsedManifest {
+    requires?: SkillRequires;
+    install?: InstallStep[];
+    setup?: SkillSetup;
+    stub?: boolean;
+    minCapabilityProfile?: string;
+    emoji?: string;
+}
+export declare function parseManifestBlock(block: string, key?: string): ParsedManifest;
+export declare function readInstall(v: unknown): InstallStep[] | undefined;
+export declare function readSetup(v: unknown): SkillSetup | undefined;

package/dist-lib/lib/tools/skills/manifest-parse.js

@@ -0,0 +1,199 @@
+export function parseManifestBlock(block, key = 'metadata') {
+    const json = extractJsonBlock(block, key);
+    if (!isObj(json) || !isObj(json.openclaw))
+        return {};
+    const oc = json.openclaw;
+    const requires = readRequires(oc.requires);
+    const install = readInstall(oc.install);
+    const setup = readSetup(oc.setup);
+    return {
+        ...(requires ? { requires } : {}),
+        ...(install ? { install } : {}),
+        ...(setup ? { setup } : {}),
+        ...(typeof oc.stub === 'boolean' ? { stub: oc.stub } : {}),
+        ...(typeof oc.minCapabilityProfile === 'string'
+            ? { minCapabilityProfile: oc.minCapabilityProfile }
+            : {}),
+        ...(typeof oc.emoji === 'string' ? { emoji: oc.emoji } : {})
+    };
+}
+function extractJsonBlock(block, key) {
+    const at = block.indexOf(`${key}:`);
+    if (at === -1)
+        return null;
+    const rest = block.slice(at + key.length + 1);
+    const start = rest.indexOf('{');
+    if (start === -1)
+        return null;
+    let depth = 0;
+    let inString = false;
+    let escaped = false;
+    for (let i = start; i < rest.length; i++) {
+        const ch = rest[i];
+        if (inString) {
+            if (escaped)
+                escaped = false;
+            else if (ch === '\\')
+                escaped = true;
+            else if (ch === '"')
+                inString = false;
+            continue;
+        }
+        if (ch === '"')
+            inString = true;
+        else if (ch === '{')
+            depth++;
+        else if (ch === '}' && --depth === 0) {
+            try {
+                return JSON.parse(rest.slice(start, i + 1));
+            }
+            catch {
+                return null;
+            }
+        }
+    }
+    return null;
+}
+function isObj(v) {
+    return typeof v === 'object' && v !== null && !Array.isArray(v);
+}
+function strArr(v) {
+    if (!Array.isArray(v))
+        return undefined;
+    return v.filter((x) => typeof x === 'string');
+}
+function readRequires(v) {
+    if (!isObj(v))
+        return undefined;
+    const bins = strArr(v.bins);
+    const mins = readBinMinVersions(v.binMinVersions);
+    const credentials = strArr(v.credentials);
+    const credentialChecks = readCredentialChecks(v.credentialChecks);
+    return bins || mins || credentials || credentialChecks
+        ? {
+            ...(bins ? { bins } : {}),
+            ...(mins ? { binMinVersions: mins } : {}),
+            ...(credentials ? { credentials } : {}),
+            ...(credentialChecks ? { credentialChecks } : {})
+        }
+        : undefined;
+}
+function readBinMinVersions(v) {
+    if (!isObj(v))
+        return undefined;
+    const out = {};
+    for (const [bin, spec] of Object.entries(v)) {
+        if (!isObj(spec) || typeof spec.min !== 'string')
+            continue;
+        out[bin] = {
+            min: spec.min,
+            ...(typeof spec.command === 'string' ? { command: spec.command } : {})
+        };
+    }
+    return Object.keys(out).length > 0 ? out : undefined;
+}
+function readCredentialChecks(v) {
+    if (!isObj(v))
+        return undefined;
+    const out = {};
+    for (const [key, check] of Object.entries(v)) {
+        if (!isObj(check) || typeof check.url !== 'string')
+            continue;
+        const headers = readStringRecord(check.headers);
+        out[key] = {
+            url: check.url,
+            ...(typeof check.method === 'string' ? { method: check.method } : {}),
+            ...(headers && Object.keys(headers).length > 0 ? { headers } : {})
+        };
+    }
+    return Object.keys(out).length > 0 ? out : undefined;
+}
+function readStringRecord(v) {
+    if (!isObj(v))
+        return undefined;
+    const out = {};
+    for (const [key, value] of Object.entries(v)) {
+        if (typeof value === 'string')
+            out[key] = value;
+    }
+    return Object.keys(out).length > 0 ? out : undefined;
+}
+export function readInstall(v) {
+    if (!Array.isArray(v))
+        return undefined;
+    const steps = [];
+    for (const raw of v) {
+        if (!isObj(raw) ||
+            typeof raw.id !== 'string' ||
+            typeof raw.kind !== 'string' ||
+            typeof raw.label !== 'string') {
+            continue;
+        }
+        const bins = strArr(raw.bins);
+        steps.push({
+            id: raw.id,
+            kind: raw.kind,
+            label: raw.label,
+            ...(typeof raw.formula === 'string' ? { formula: raw.formula } : {}),
+            ...(bins ? { bins } : {}),
+            ...(typeof raw.command === 'string' ? { command: raw.command } : {}),
+            ...(typeof raw.manual === 'boolean' ? { manual: raw.manual } : {})
+        });
+    }
+    return steps.length > 0 ? steps : undefined;
+}
+const ROUTE_KINDS = new Set(['oauth', 'token', 'install', 'picker', 'instructions']);
+function isRouteKind(v) {
+    return typeof v === 'string' && ROUTE_KINDS.has(v);
+}
+export function readSetup(v) {
+    if (!isObj(v))
+        return undefined;
+    const summary = typeof v.summary === 'string' ? v.summary : undefined;
+    const routes = readRoutes(v.routes);
+    return summary || routes
+        ? { ...(summary ? { summary } : {}), ...(routes ? { routes } : {}) }
+        : undefined;
+}
+function readRoutes(v) {
+    if (!Array.isArray(v))
+        return undefined;
+    const routes = [];
+    for (const raw of v) {
+        if (!isObj(raw) || !isRouteKind(raw.kind) || typeof raw.label !== 'string')
+            continue;
+        const steps = strArr(raw.steps);
+        const configSteps = strArr(raw.configSteps);
+        const fields = readFields(raw.fields);
+        routes.push({
+            kind: raw.kind,
+            label: raw.label,
+            ...(typeof raw.provider === 'string' ? { provider: raw.provider } : {}),
+            ...(typeof raw.credentialKey === 'string' ? { credentialKey: raw.credentialKey } : {}),
+            ...(typeof raw.description === 'string' ? { description: raw.description } : {}),
+            ...(typeof raw.helpUrl === 'string' ? { helpUrl: raw.helpUrl } : {}),
+            ...(steps ? { steps } : {}),
+            ...(configSteps ? { configSteps } : {}),
+            ...(fields ? { fields } : {}),
+            ...(typeof raw.satisfied === 'boolean' ? { satisfied: raw.satisfied } : {})
+        });
+    }
+    return routes.length > 0 ? routes : undefined;
+}
+function readFields(v) {
+    if (!Array.isArray(v))
+        return undefined;
+    const fields = [];
+    for (const raw of v) {
+        if (!isObj(raw) || typeof raw.key !== 'string' || typeof raw.label !== 'string')
+            continue;
+        fields.push({
+            key: raw.key,
+            label: raw.label,
+            ...(typeof raw.placeholder === 'string' ? { placeholder: raw.placeholder } : {}),
+            ...(typeof raw.secret === 'boolean' ? { secret: raw.secret } : {}),
+            ...(typeof raw.required === 'boolean' ? { required: raw.required } : {})
+        });
+    }
+    return fields.length > 0 ? fields : undefined;
+}

package/dist-lib/lib/tools/skills/manifest.d.ts

@@ -0,0 +1,47 @@
+import type { SkillCli } from './cli-schema.ts';
+export type { SkillCli };
+export interface SkillRequires {
+    readonly bins?: readonly string[];
+    readonly binMinVersions?: Readonly<Record<string, {
+        readonly min: string;
+        readonly command?: string;
+    }>>;
+    readonly credentials?: readonly string[];
+    readonly credentialChecks?: Readonly<Record<string, {
+        readonly url: string;
+        readonly method?: string;
+        readonly headers?: Readonly<Record<string, string>>;
+    }>>;
+}
+export interface InstallStep {
+    readonly id: string;
+    readonly kind: string;
+    readonly label: string;
+    readonly formula?: string;
+    readonly bins?: readonly string[];
+    readonly command?: string;
+    readonly manual?: boolean;
+}
+export interface SkillSetupField {
+    readonly key: string;
+    readonly label: string;
+    readonly placeholder?: string;
+    readonly secret?: boolean;
+    readonly required?: boolean;
+}
+export interface SkillSetupRoute {
+    readonly kind: 'oauth' | 'token' | 'install' | 'picker' | 'instructions';
+    readonly label: string;
+    readonly provider?: string;
+    readonly credentialKey?: string;
+    readonly description?: string;
+    readonly helpUrl?: string;
+    readonly steps?: readonly string[];
+    readonly configSteps?: readonly string[];
+    readonly fields?: readonly SkillSetupField[];
+    readonly satisfied?: boolean;
+}
+export interface SkillSetup {
+    readonly summary?: string;
+    readonly routes?: readonly SkillSetupRoute[];
+}

package/dist-lib/lib/tools/skills/manifest.js

@@ -0,0 +1 @@
+export {};

package/dist-lib/lib/tools/skills/mention-name.d.ts

@@ -0,0 +1 @@
+export declare function skillMentionName(text: string): string | null;

package/dist-lib/lib/tools/skills/mention-name.js

@@ -0,0 +1,4 @@
+const MENTION_PATTERN = /^@([a-z0-9][a-z0-9_-]*)(?=\s|$)/;
+export function skillMentionName(text) {
+    return MENTION_PATTERN.exec(text.trimStart().toLowerCase())?.[1] ?? null;
+}

package/dist-lib/lib/tools/skills/mention.d.ts

@@ -0,0 +1,6 @@
+import type { SkillCatalogEntry } from './catalog.ts';
+import { skillMentionName } from './mention-name.ts';
+export { skillMentionName };
+export declare function resolveSkillMention(text: string, catalog: readonly SkillCatalogEntry[]): SkillCatalogEntry | null;
+export declare function resolveImplicitSkill(text: string, activeSkills: readonly SkillCatalogEntry[]): SkillCatalogEntry | null;
+export declare function skillPreloadMessage(content: string, name: string, body: string): string;

package/dist-lib/lib/tools/skills/mention.js

@@ -0,0 +1,42 @@
+import { has } from 'asenion';
+import { skillMentionName } from "./mention-name.js";
+export { skillMentionName };
+export function resolveSkillMention(text, catalog) {
+    const name = skillMentionName(text);
+    if (!name)
+        return null;
+    return catalog.find((skill) => skill.name.toLowerCase() === name) ?? null;
+}
+const MIN_IMPLICIT_NAME_LENGTH = 4;
+function matchesName(text, candidate) {
+    for (const part of candidate.split('+')) {
+        if (!has(text, part))
+            return false;
+    }
+    return true;
+}
+export function resolveImplicitSkill(text, activeSkills) {
+    let best = null;
+    let bestLength = 0;
+    for (const skill of activeSkills) {
+        const names = skill.preloadOnName === false
+            ? (skill.aliases ?? [])
+            : [skill.name, ...(skill.aliases ?? [])];
+        for (const word of names) {
+            const candidate = word.toLowerCase();
+            if (candidate.length < MIN_IMPLICIT_NAME_LENGTH)
+                continue;
+            if (!matchesName(text, candidate))
+                continue;
+            const weight = candidate.replace(/\+/g, '').length;
+            if (weight > bestLength) {
+                best = skill;
+                bestLength = weight;
+            }
+        }
+    }
+    return best;
+}
+export function skillPreloadMessage(content, name, body) {
+    return `[Skill invoked by user: ${name}]\n${body}\n\nThe user's message:\n${content}`;
+}