@easbot/skills 0.2.48

package/dist/index.d.cts

@@ -0,0 +1,648 @@
+import { AgentResult } from '@vercel/detect-agent';
+import { IGlobal, IInstance, ISubAgentRunner } from '@easbot/types';
+
+type AgentType = 'aider-desk' | 'amp' | 'antigravity' | 'easbot' | 'antigravity-cli' | 'astrbot' | 'autohand-code' | 'augment' | 'bob' | 'claude-code' | 'openclaw' | 'cline' | 'codearts-agent' | 'codebuddy' | 'codemaker' | 'codestudio' | 'codex' | 'command-code' | 'continue' | 'cortex' | 'crush' | 'cursor' | 'deepagents' | 'devin' | 'dexto' | 'droid' | 'eve' | 'firebender' | 'forgecode' | 'gemini-cli' | 'github-copilot' | 'goose' | 'hermes-agent' | 'inference-sh' | 'iflow-cli' | 'jazz' | 'junie' | 'kilo' | 'kimi-code-cli' | 'kiro-cli' | 'kode' | 'lingma' | 'loaf' | 'mcpjam' | 'mistral-vibe' | 'moxby' | 'mux' | 'neovate' | 'opencode' | 'openhands' | 'ona' | 'pi' | 'qoder' | 'qoder-cn' | 'qwen-code' | 'replit' | 'reasonix' | 'roo' | 'rovodev' | 'tabnine-cli' | 'terramind' | 'tinycloud' | 'trae' | 'trae-cn' | 'warp' | 'windsurf' | 'zed' | 'zencoder' | 'zenflow' | 'pochi' | 'promptscript' | 'adal' | 'universal';
+interface Skill {
+    name: string;
+    description: string;
+    path: string;
+    rawContent?: string;
+    pluginName?: string;
+    metadata?: Record<string, unknown>;
+}
+interface AgentConfig {
+    name: string;
+    displayName: string;
+    skillsDir: string;
+    globalSkillsDir: string | undefined;
+    detectInstalled: () => Promise<boolean>;
+    showInUniversalList?: boolean;
+    showInUniversalPrompt?: boolean;
+}
+interface ParsedSource {
+    type: 'github' | 'gitlab' | 'git' | 'local' | 'well-known';
+    url: string;
+    subpath?: string;
+    localPath?: string;
+    ref?: string;
+    skillFilter?: string;
+}
+interface RemoteSkill$1 {
+    name: string;
+    description: string;
+    content: string;
+    installName: string;
+    sourceUrl: string;
+    providerId: string;
+    sourceIdentifier: string;
+    metadata?: Record<string, unknown>;
+}
+
+declare function getOpenClawGlobalSkillsDir(homeDir?: string, pathExists?: (path: string) => boolean): string;
+declare const agents: Record<AgentType, AgentConfig>;
+declare function detectInstalledAgents(): Promise<AgentType[]>;
+declare function getAgentConfig(type: AgentType): AgentConfig;
+declare const EVE_SUBAGENTS_DIR: string;
+declare function getEveSubagents(cwd?: string): string[];
+declare function getUniversalAgents(): AgentType[];
+declare function getVisibleUniversalAgents(): AgentType[];
+declare function getNonUniversalAgents(): AgentType[];
+declare function isUniversalAgent(type: AgentType): boolean;
+
+declare function shouldInstallInternalSkills(): boolean;
+declare function parseSkillMd(skillMdPath: string, options?: {
+    includeInternal?: boolean;
+}): Promise<Skill | null>;
+interface DiscoverSkillsOptions {
+    includeInternal?: boolean;
+    fullDepth?: boolean;
+}
+declare function isSubpathSafe(basePath: string, subpath: string): boolean;
+declare function discoverSkills(basePath: string, subpath?: string, options?: DiscoverSkillsOptions): Promise<Skill[]>;
+declare function getSkillDisplayName(skill: Skill): string;
+declare function filterSkills(skills: Skill[], inputNames: string[]): Skill[];
+
+interface RemoteSkill {
+    name: string;
+    description: string;
+    content: string;
+    installName: string;
+    sourceUrl: string;
+    metadata?: Record<string, unknown>;
+}
+interface ProviderMatch {
+    matches: boolean;
+    sourceIdentifier?: string;
+}
+interface HostProvider {
+    readonly id: string;
+    readonly displayName: string;
+    match(url: string): ProviderMatch;
+    fetchSkill(url: string): Promise<RemoteSkill | null>;
+    toRawUrl(url: string): string;
+    getSourceIdentifier(url: string): string;
+}
+interface ProviderRegistry {
+    register(provider: HostProvider): void;
+    findProvider(url: string): HostProvider | null;
+    getProviders(): HostProvider[];
+}
+
+declare const DISCOVERY_SCHEMA_V2 = "https://schemas.agentskills.io/discovery/0.2.0/schema.json";
+interface WellKnownIndexV1 {
+    skills: WellKnownSkillEntryV1[];
+}
+interface WellKnownSkillEntryV1 {
+    name: string;
+    description: string;
+    files: string[];
+}
+interface WellKnownIndexV2 {
+    $schema: typeof DISCOVERY_SCHEMA_V2;
+    skills: WellKnownSkillEntryV2[];
+}
+interface WellKnownSkillEntryV2 {
+    name: string;
+    type: 'skill-md' | 'archive';
+    description: string;
+    url: string;
+    digest: string;
+}
+type WellKnownIndex = WellKnownIndexV1 | WellKnownIndexV2;
+type WellKnownSkillEntry = WellKnownSkillEntryV1 | WellKnownSkillEntryV2;
+type WellKnownFileContent = string | Uint8Array;
+type NormalizedWellKnownEntry = {
+    version: '0.1.0';
+    name: string;
+    description: string;
+    files: string[];
+    baseUrl: string;
+    wellKnownPath: string;
+    indexEntry: WellKnownSkillEntryV1;
+} | {
+    version: '0.2.0';
+    name: string;
+    description: string;
+    type: 'skill-md' | 'archive';
+    artifactUrl: string;
+    digest: string;
+    indexEntry: WellKnownSkillEntryV2;
+};
+interface WellKnownSkill extends RemoteSkill {
+    files: Map<string, WellKnownFileContent>;
+    indexEntry: WellKnownSkillEntry;
+}
+declare class WellKnownProvider implements HostProvider {
+    readonly id = "well-known";
+    readonly displayName = "Well-Known Skills";
+    private readonly WELL_KNOWN_PATHS;
+    private readonly INDEX_FILE;
+    match(url: string): ProviderMatch;
+    fetchIndex(baseUrl: string): Promise<{
+        index: WellKnownIndex;
+        entries: NormalizedWellKnownEntry[];
+        resolvedBaseUrl: string;
+        resolvedWellKnownPath: string;
+        indexUrl: string;
+    } | null>;
+    private fetchIndexCandidates;
+    private normalizeIndex;
+    private getLegacySkillBaseUrl;
+    private isValidSkillName;
+    private isSafeLegacyFilePath;
+    private isValidSkillEntryV1;
+    private isValidSkillEntryV2;
+    fetchSkill(url: string): Promise<RemoteSkill | null>;
+    fetchSkillByEntry(baseUrlOrEntry: string | NormalizedWellKnownEntry, legacyEntry?: WellKnownSkillEntryV1, legacyWellKnownPath?: string): Promise<WellKnownSkill | null>;
+    private fetchLegacySkillByEntry;
+    private fetchArtifactSkillByEntry;
+    private createSkill;
+    fetchAllSkills(url: string): Promise<WellKnownSkill[]>;
+    private computeDigest;
+    private extractArchive;
+    private isZipArchive;
+    private isTarGzArchive;
+    private normalizeArchivePath;
+    private addArchiveFile;
+    private extractTarGz;
+    private readTarString;
+    private extractZip;
+    private findZipEndOfCentralDirectory;
+    toRawUrl(url: string): string;
+    getSourceIdentifier(url: string): string;
+    hasSkillsIndex(url: string): Promise<boolean>;
+}
+declare const wellKnownProvider: WellKnownProvider;
+
+type InstallMode = 'symlink' | 'copy';
+interface InstallResult {
+    success: boolean;
+    path: string;
+    canonicalPath?: string;
+    mode: InstallMode;
+    symlinkFailed?: boolean;
+    skipped?: boolean;
+    error?: string;
+}
+declare function sanitizeName(name: string): string;
+declare function getCanonicalSkillsDir(global: boolean, cwd?: string): string;
+declare function getEveSubagentSkillsDir(subagent: string, cwd?: string): string;
+declare function getAgentBaseDir(agentType: AgentType, global: boolean, cwd?: string, eveSubagent?: string): string;
+declare function installSkillForAgent(skill: Skill, agentType: AgentType, options?: {
+    global?: boolean;
+    cwd?: string;
+    mode?: InstallMode;
+    eveSubagent?: string;
+}): Promise<InstallResult>;
+declare function isSkillInstalled(skillName: string, agentType: AgentType, options?: {
+    global?: boolean;
+    cwd?: string;
+    eveSubagent?: string;
+}): Promise<boolean>;
+declare function getInstallPath(skillName: string, agentType: AgentType, options?: {
+    global?: boolean;
+    cwd?: string;
+    eveSubagent?: string;
+}): string;
+declare function getCanonicalPath(skillName: string, options?: {
+    global?: boolean;
+    cwd?: string;
+    agent?: AgentType;
+    eveSubagent?: string;
+}): string;
+declare function installRemoteSkillForAgent(skill: RemoteSkill$1, agentType: AgentType, options?: {
+    global?: boolean;
+    cwd?: string;
+    mode?: InstallMode;
+    eveSubagent?: string;
+}): Promise<InstallResult>;
+declare function installWellKnownSkillForAgent(skill: WellKnownSkill, agentType: AgentType, options?: {
+    global?: boolean;
+    cwd?: string;
+    mode?: InstallMode;
+    eveSubagent?: string;
+}): Promise<InstallResult>;
+declare function installBlobSkillForAgent(skill: {
+    installName: string;
+    files: Array<{
+        path: string;
+        contents: string;
+    }>;
+}, agentType: AgentType, options?: {
+    global?: boolean;
+    cwd?: string;
+    mode?: InstallMode;
+    eveSubagent?: string;
+}): Promise<InstallResult>;
+interface InstalledSkill {
+    name: string;
+    description: string;
+    path: string;
+    canonicalPath: string;
+    scope: 'project' | 'global';
+    agents: AgentType[];
+}
+declare function listInstalledSkills(options?: {
+    global?: boolean;
+    cwd?: string;
+    agentFilter?: AgentType[];
+}): Promise<InstalledSkill[]>;
+
+declare function getOwnerRepo(parsed: ParsedSource): string | null;
+declare function parseOwnerRepo(ownerRepo: string): {
+    owner: string;
+    repo: string;
+} | null;
+declare function isRepoPrivate(owner: string, repo: string): Promise<boolean | null>;
+declare function sanitizeSubpath(subpath: string): string;
+declare function parseSource(input: string): ParsedSource;
+
+declare function initTelemetry(version: string): void;
+interface AddOptions {
+    global?: boolean;
+    agent?: string[];
+    yes?: boolean;
+    skill?: string[];
+    list?: boolean;
+    all?: boolean;
+    fullDepth?: boolean;
+    copy?: boolean;
+    subagent?: string[];
+}
+declare function runAdd(args: string[], options?: AddOptions): Promise<void>;
+declare function parseAddOptions(args: string[]): {
+    source: string[];
+    options: AddOptions;
+};
+
+interface SearchSkill {
+    name: string;
+    slug: string;
+    source: string;
+    installs: number;
+}
+interface FindOptions {
+    owner?: string;
+}
+interface ParseFindOptionsResult {
+    query: string;
+    options: FindOptions;
+    errors: string[];
+}
+declare function parseFindOptions(args: string[]): ParseFindOptionsResult;
+declare function searchSkillsAPI(query: string, owner?: string): Promise<SearchSkill[]>;
+declare function runFind(args: string[]): Promise<void>;
+
+interface ListOptions {
+    global?: boolean;
+    agent?: string[];
+    json?: boolean;
+}
+declare function parseListOptions(args: string[]): ListOptions;
+declare function runList(args: string[]): Promise<void>;
+
+interface RemoveOptions {
+    global?: boolean;
+    agent?: string[];
+    yes?: boolean;
+    all?: boolean;
+}
+declare function removeCommand(skillNames: string[], options: RemoveOptions): Promise<void>;
+declare function parseRemoveOptions(args: string[]): {
+    skills: string[];
+    options: RemoveOptions;
+};
+
+interface SkillLockEntry {
+    source: string;
+    sourceType: string;
+    sourceUrl: string;
+    ref?: string;
+    skillPath?: string;
+    skillFolderHash: string;
+    installedAt: string;
+    updatedAt: string;
+    pluginName?: string;
+}
+interface DismissedPrompts {
+    findSkillsPrompt?: boolean;
+}
+interface SkillLockFile {
+    version: number;
+    skills: Record<string, SkillLockEntry>;
+    dismissed?: DismissedPrompts;
+    lastSelectedAgents?: string[];
+}
+declare function getSkillLockPath(): string;
+declare function readSkillLock(): Promise<SkillLockFile>;
+declare function writeSkillLock(lock: SkillLockFile): Promise<void>;
+declare function computeContentHash(content: string): string;
+declare function resetGhAuthWarning(): void;
+declare function getGitHubToken(): string | null;
+declare function fetchSkillFolderHash(ownerRepo: string, skillPath: string, getToken?: (() => string | null) | null, ref?: string): Promise<string | null>;
+declare function addSkillToLock(skillName: string, entry: Omit<SkillLockEntry, 'installedAt' | 'updatedAt'>): Promise<void>;
+declare function removeSkillFromLock(skillName: string): Promise<boolean>;
+declare function getSkillFromLock(skillName: string): Promise<SkillLockEntry | null>;
+declare function getAllLockedSkills(): Promise<Record<string, SkillLockEntry>>;
+declare function getSkillsBySource(): Promise<Map<string, {
+    skills: string[];
+    entry: SkillLockEntry;
+}>>;
+declare function isPromptDismissed(promptKey: keyof DismissedPrompts): Promise<boolean>;
+declare function dismissPrompt(promptKey: keyof DismissedPrompts): Promise<void>;
+declare function getLastSelectedAgents(): Promise<string[] | undefined>;
+declare function saveSelectedAgents(agents: string[]): Promise<void>;
+
+interface LocalSkillLockEntry {
+    source: string;
+    ref?: string;
+    sourceType: string;
+    skillPath?: string;
+    computedHash: string;
+    subagents?: string[];
+}
+interface LocalSkillLockFile {
+    version: number;
+    skills: Record<string, LocalSkillLockEntry>;
+}
+declare function getLocalLockPath(cwd?: string): string;
+declare function readLocalLock(cwd?: string): Promise<LocalSkillLockFile>;
+declare function writeLocalLock(lock: LocalSkillLockFile, cwd?: string): Promise<void>;
+declare function computeSkillFolderHash(skillDir: string): Promise<string>;
+declare function addSkillToLocalLock(skillName: string, entry: LocalSkillLockEntry, cwd?: string): Promise<void>;
+declare function removeSkillFromLocalLock(skillName: string, cwd?: string): Promise<boolean>;
+
+type UpdateScope = 'project' | 'global' | 'both';
+interface UpdateCheckOptions {
+    global?: boolean;
+    project?: boolean;
+    yes?: boolean;
+    skills?: string[];
+}
+declare function parseUpdateOptions(args: string[]): UpdateCheckOptions;
+declare function hasProjectSkills(cwd?: string): boolean;
+declare function resolveUpdateScope(options: UpdateCheckOptions): Promise<UpdateScope>;
+declare function matchesSkillFilter(name: string, filter?: string[]): boolean;
+declare function runUpdate(args?: string[]): Promise<void>;
+
+declare function runInstallFromLock(args: string[]): Promise<void>;
+
+interface SyncOptions {
+    agent?: string[];
+    yes?: boolean;
+    force?: boolean;
+}
+declare function runSync(args: string[], options?: SyncOptions): Promise<void>;
+declare function parseSyncOptions(args: string[]): {
+    options: SyncOptions;
+};
+
+interface UseOptions {
+    skill?: string;
+    agent?: string[];
+    fullDepth?: boolean;
+    dangerouslyAcceptOpenclawRisks?: boolean;
+    help?: boolean;
+}
+interface ParseUseOptionsResult {
+    source: string[];
+    options: UseOptions;
+    errors: string[];
+}
+type UseSkill = {
+    kind: 'blob';
+    name: string;
+    directoryName: string;
+    rawContent: string;
+    files: Array<{
+        path: string;
+        contents: string;
+    }>;
+} | {
+    kind: 'disk';
+    name: string;
+    directoryName: string;
+    rawContent?: string;
+    path: string;
+} | {
+    kind: 'well-known';
+    name: string;
+    directoryName: string;
+    rawContent: string;
+    files: Map<string, WellKnownFileContent>;
+};
+interface MaterializedUseSkill {
+    tempRoot: string;
+    skillDir: string;
+    skillMd: string;
+    hasSupportingFiles: boolean;
+}
+interface AgentProcess {
+    on: (event: 'error' | 'close', listener: (...args: any[]) => void) => AgentProcess;
+}
+type AgentSpawn = (command: string, args: string[], options: {
+    stdio: 'inherit';
+}) => AgentProcess;
+declare function parseUseOptions(args: string[]): ParseUseOptionsResult;
+declare function buildUsePrompt(input: {
+    skillMd: string;
+    supportDir?: string;
+    hasSupportingFiles: boolean;
+}): string;
+declare function materializeUseSkill(skill: UseSkill): Promise<MaterializedUseSkill>;
+declare function runUse(sourceArgs: string[], options?: UseOptions, parseErrors?: string[]): Promise<void>;
+declare function launchAgentInteractively(agent: AgentType, prompt: string, spawnImpl?: AgentSpawn): Promise<number>;
+
+declare const DEFAULT_CLONE_TIMEOUT_MS = 300000;
+interface GitHubRepoInfo {
+    owner: string;
+    repo: string;
+    slug: string;
+    sshUrl: string;
+}
+declare class GitCloneError extends Error {
+    readonly url: string;
+    readonly isTimeout: boolean;
+    readonly isAuthError: boolean;
+    constructor(message: string, url: string, isTimeout?: boolean, isAuthError?: boolean);
+}
+declare function parseGitHubRepoUrl(url: string): GitHubRepoInfo | null;
+declare function isGitHubHttpsCloneUrl(url: string): boolean;
+declare function isGitHubSsoAuthError(message: string): boolean;
+declare function cloneRepo(url: string, ref?: string): Promise<string>;
+declare function cleanupTempDir(dir: string): Promise<void>;
+
+interface SkillSnapshotFile {
+    path: string;
+    contents: string;
+}
+interface SkillDownloadResponse {
+    files: SkillSnapshotFile[];
+    hash: string;
+}
+interface BlobSkill extends Skill {
+    files: SkillSnapshotFile[];
+    snapshotHash: string;
+    repoPath: string;
+}
+declare const BLOB_ALLOWED_REPOS: Record<string, {
+    downloadUrl: (slug: string) => string;
+}>;
+declare function toSkillSlug(name: string): string;
+interface TreeEntry {
+    path: string;
+    type: 'blob' | 'tree';
+    sha: string;
+    size?: number;
+}
+interface RepoTree {
+    sha: string;
+    branch: string;
+    tree: TreeEntry[];
+}
+declare function resetRepoTreeAuthState(): void;
+declare function fetchRepoTree(ownerRepo: string, ref?: string, getToken?: () => string | null): Promise<RepoTree | null>;
+declare function getSkillFolderHashFromTree(tree: RepoTree, skillPath: string): string | null;
+declare function findSkillMdPaths(tree: RepoTree, subpath?: string): string[];
+interface BlobInstallResult {
+    skills: BlobSkill[];
+    tree: RepoTree;
+}
+declare function tryBlobInstall(ownerRepo: string, options?: {
+    subpath?: string;
+    skillFilter?: string;
+    ref?: string;
+    getToken?: () => string | null;
+    includeInternal?: boolean;
+}): Promise<BlobInstallResult | null>;
+
+interface InstallTelemetryData {
+    event: 'install';
+    source: string;
+    skills: string;
+    agents: string;
+    global?: '1';
+    skillFiles?: string;
+    sourceType?: string;
+}
+interface RemoveTelemetryData {
+    event: 'remove';
+    source?: string;
+    skills: string;
+    agents: string;
+    global?: '1';
+    sourceType?: string;
+}
+interface UpdateTelemetryData {
+    event: 'update';
+    scope?: string;
+    skillCount: string;
+    successCount: string;
+    failCount: string;
+}
+interface FindTelemetryData {
+    event: 'find';
+    query: string;
+    resultCount: string;
+    interactive?: '1';
+}
+interface SyncTelemetryData {
+    event: 'experimental_sync';
+    skillCount: string;
+    successCount: string;
+    agents: string;
+}
+type TelemetryData = InstallTelemetryData | RemoveTelemetryData | UpdateTelemetryData | FindTelemetryData | SyncTelemetryData;
+declare function setDetectedAgent(agentName: string | null): void;
+declare function setVersion(version: string): void;
+interface PartnerAudit {
+    risk: 'safe' | 'low' | 'medium' | 'high' | 'critical' | 'unknown';
+    alerts?: number;
+    score?: number;
+    analyzedAt: string;
+}
+type SkillAuditData = Record<string, PartnerAudit>;
+type AuditResponse = Record<string, SkillAuditData>;
+declare function fetchAuditData(source: string, skillSlugs: string[], timeoutMs?: number): Promise<AuditResponse | null>;
+declare function track(data: TelemetryData): void;
+declare function flushTelemetry(timeoutMs?: number): Promise<void>;
+
+declare function stripTerminalEscapes(str: string): string;
+declare function sanitizeMetadata(str: string): string;
+
+declare function detectAgent(): Promise<AgentResult>;
+declare function isRunningInAgent(): Promise<boolean>;
+declare function getAgentName(): Promise<string | null>;
+declare function getAgentType(agentName: string): AgentType | null;
+
+declare class ProviderRegistryImpl implements ProviderRegistry {
+    private providers;
+    register(provider: HostProvider): void;
+    findProvider(url: string): HostProvider | null;
+    getProviders(): HostProvider[];
+}
+declare const registry: ProviderRegistryImpl;
+declare function registerProvider(provider: HostProvider): void;
+declare function findProvider(url: string): HostProvider | null;
+declare function getProviders(): HostProvider[];
+
+declare const AGENTS_DIR = ".agents";
+declare const SKILLS_SUBDIR = "skills";
+declare const UNIVERSAL_SKILLS_DIR = ".agents/skills";
+
+declare function parseFrontmatter(raw: string): {
+    data: Record<string, unknown>;
+    content: string;
+};
+
+declare const I18n: {
+    readonly defaultLocale: "zh-CN";
+    readonly timeZone: "Asia/Shanghai";
+    readonly locales: string[];
+};
+type Locale = (typeof I18n)['locales'][number];
+
+interface SkillsCliDeps {
+    version?: string;
+    cwd?: string;
+    inAgent?: boolean;
+    locale?: Locale;
+}
+interface SkillsCliResult {
+    code: number;
+    handled: boolean;
+    command?: string;
+}
+declare function renderBanner(deps?: SkillsCliDeps): void;
+declare function renderHelp(deps?: SkillsCliDeps): void;
+declare function handleSkillsCli(args: string[], deps?: SkillsCliDeps): Promise<SkillsCliResult>;
+
+interface SkillsAgentAdapter {
+    global: IGlobal;
+    instance: IInstance;
+    subAgentRunner?: ISubAgentRunner;
+    localAgentRunner?: unknown;
+    triggerEvent?: (event: string, input: unknown, context?: Record<string, unknown>) => Promise<{
+        success: boolean;
+        output: unknown;
+        modified: boolean;
+    }>;
+}
+declare function setGlobalAdapter(global: IGlobal | null): void;
+declare function resetGlobalAdapter(): void;
+declare function getGlobal(): IGlobal;
+declare function setInstanceAdapter(instance: IInstance | null): void;
+declare function resetInstanceAdapter(): void;
+declare function getInstance(): IInstance;
+declare function setAgentAdapter(adapter: SkillsAgentAdapter | null): void;
+declare function getAgentAdapter(): SkillsAgentAdapter | null;
+declare function hasAgentAdapter(): boolean;
+declare function requireAgentAdapter(): SkillsAgentAdapter;
+declare function getHomeDir(): string;
+declare function getXdgConfig(): string;
+declare function getXdgData(): string;
+declare function getXdgState(): string;
+declare function getXdgCache(): string;
+declare function getProjectDirectory(): string;
+
+export { AGENTS_DIR, type AddOptions, type AgentConfig, type AgentProcess, type AgentSpawn, type AgentType, type AuditResponse, BLOB_ALLOWED_REPOS, type BlobInstallResult, type BlobSkill, DEFAULT_CLONE_TIMEOUT_MS, type DiscoverSkillsOptions, type DismissedPrompts, EVE_SUBAGENTS_DIR, type FindOptions, GitCloneError, type HostProvider, type InstallMode, type InstalledSkill, type LocalSkillLockEntry, type LocalSkillLockFile, type MaterializedUseSkill, type ParseFindOptionsResult, type ParseUseOptionsResult, type ParsedSource, type PartnerAudit, type ProviderMatch, type ProviderRegistry, type RemoteSkill as ProviderRemoteSkill, type RemoteSkill$1 as RemoteSkill, type RemoveOptions, type RepoTree, SKILLS_SUBDIR, type SearchSkill, type Skill, type SkillAuditData, type SkillDownloadResponse, type SkillLockEntry, type SkillLockFile, type SkillSnapshotFile, type SkillsAgentAdapter, type SkillsCliDeps, type SkillsCliResult, type SyncOptions, type TreeEntry, UNIVERSAL_SKILLS_DIR, type UpdateCheckOptions, type UpdateScope, type UseOptions, type UseSkill, type WellKnownFileContent, type WellKnownIndex, type WellKnownIndexV1, type WellKnownIndexV2, WellKnownProvider, type WellKnownSkill, type WellKnownSkillEntry, type WellKnownSkillEntryV1, type WellKnownSkillEntryV2, addSkillToLocalLock, addSkillToLock, agents, buildUsePrompt, cleanupTempDir, cloneRepo, computeContentHash, computeSkillFolderHash, detectAgent, detectInstalledAgents, discoverSkills, dismissPrompt, fetchAuditData, fetchRepoTree, fetchSkillFolderHash, filterSkills, findProvider, findSkillMdPaths, flushTelemetry, getAgentAdapter, getAgentBaseDir, getAgentConfig, getAgentName, getAgentType, getAllLockedSkills, getCanonicalPath, getCanonicalSkillsDir, getEveSubagentSkillsDir, getEveSubagents, getGitHubToken, getGlobal, getHomeDir, getInstallPath, getInstance, getLastSelectedAgents, getLocalLockPath, getNonUniversalAgents, getOpenClawGlobalSkillsDir, getOwnerRepo, getProjectDirectory, getProviders, getSkillDisplayName, getSkillFolderHashFromTree, getSkillFromLock, getSkillLockPath, getSkillsBySource, getUniversalAgents, getVisibleUniversalAgents, getXdgCache, getXdgConfig, getXdgData, getXdgState, handleSkillsCli, hasAgentAdapter, hasProjectSkills, initTelemetry, installBlobSkillForAgent, installRemoteSkillForAgent, installSkillForAgent, installWellKnownSkillForAgent, isGitHubHttpsCloneUrl, isGitHubSsoAuthError, isPromptDismissed, isRepoPrivate, isRunningInAgent, isSkillInstalled, isSubpathSafe, isUniversalAgent, launchAgentInteractively, listInstalledSkills, matchesSkillFilter, materializeUseSkill, parseAddOptions, parseFindOptions, parseFrontmatter, parseGitHubRepoUrl, parseListOptions, parseOwnerRepo, parseRemoveOptions, parseSkillMd, parseSource, parseSyncOptions, parseUpdateOptions, parseUseOptions, readLocalLock, readSkillLock, registerProvider, registry, removeCommand, removeSkillFromLocalLock, removeSkillFromLock, renderBanner, renderHelp, requireAgentAdapter, resetGhAuthWarning, resetGlobalAdapter, resetInstanceAdapter, resetRepoTreeAuthState, resolveUpdateScope, runAdd, runFind, runInstallFromLock, runList, runSync, runUpdate, runUse, sanitizeMetadata, sanitizeName, sanitizeSubpath, saveSelectedAgents, searchSkillsAPI, setAgentAdapter, setDetectedAgent, setGlobalAdapter, setInstanceAdapter, setVersion, shouldInstallInternalSkills, stripTerminalEscapes, toSkillSlug, track, tryBlobInstall, wellKnownProvider, writeLocalLock, writeSkillLock };