profclaw 0.0.1-beta.1

package/dist/plugins/clawhub.js

@@ -0,0 +1,260 @@
+/**
+ * ClawHub Integration Client
+ *
+ * Fetches and installs skills from OpenClaw's ClawHub marketplace.
+ * ClawHub skills use the same SKILL.md format that profClaw supports natively.
+ *
+ * Strategy: Use GitHub search + raw content APIs to discover and download
+ * OpenClaw-compatible skills, since ClawHub's skills are published as
+ * GitHub repos/directories.
+ */
+import { existsSync, mkdirSync, writeFileSync, readFileSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+const MANAGED_SKILLS_DIR = join(homedir(), '.profclaw', 'skills');
+const CLAWHUB_STATE_FILE = join(homedir(), '.profclaw', 'clawhub.json');
+const GITHUB_API = 'https://api.github.com';
+// ClawHub Client
+class ClawHubClient {
+    state;
+    githubToken;
+    constructor() {
+        this.state = this.loadState();
+        this.githubToken = process.env.GITHUB_TOKEN;
+    }
+    /**
+     * Search for OpenClaw-compatible skills on GitHub
+     */
+    async search(query) {
+        // Check cache first (valid for 1 hour)
+        if (this.state.cacheExpiry && new Date(this.state.cacheExpiry) > new Date() && !query) {
+            return this.state.cache;
+        }
+        const skills = [];
+        // Strategy 1: Search GitHub for SKILL.md files in openclaw/community repos
+        const ghSkills = await this.searchGitHub(query);
+        skills.push(...ghSkills);
+        // Strategy 2: Fetch from awesome-openclaw-skills curated list
+        const awesomeSkills = await this.fetchAwesomeList();
+        skills.push(...awesomeSkills);
+        // Deduplicate by name
+        const seen = new Set();
+        const deduplicated = skills.filter((s) => {
+            const key = `${s.author}/${s.name}`;
+            if (seen.has(key))
+                return false;
+            seen.add(key);
+            return true;
+        });
+        // Update cache
+        this.state.cache = deduplicated;
+        this.state.lastSearch = new Date().toISOString();
+        this.state.cacheExpiry = new Date(Date.now() + 60 * 60 * 1000).toISOString(); // 1h
+        this.saveState();
+        return deduplicated;
+    }
+    /**
+     * Install a skill from ClawHub/GitHub into ~/.profclaw/skills/
+     */
+    async install(skill) {
+        // Check if already installed
+        const existing = this.state.installed.find((s) => s.name === skill.name);
+        if (existing) {
+            throw new Error(`Skill "${skill.name}" is already installed at ${existing.localPath}`);
+        }
+        // Ensure managed skills directory exists
+        if (!existsSync(MANAGED_SKILLS_DIR)) {
+            mkdirSync(MANAGED_SKILLS_DIR, { recursive: true });
+        }
+        // Create skill directory
+        const skillDir = join(MANAGED_SKILLS_DIR, skill.name);
+        if (!existsSync(skillDir)) {
+            mkdirSync(skillDir, { recursive: true });
+        }
+        // Download SKILL.md from GitHub
+        const skillMdContent = await this.downloadSkillMd(skill);
+        writeFileSync(join(skillDir, 'SKILL.md'), skillMdContent);
+        const installed = {
+            name: skill.name,
+            repo: skill.repo,
+            installedAt: new Date().toISOString(),
+            localPath: skillDir,
+        };
+        this.state.installed.push(installed);
+        this.saveState();
+        return installed;
+    }
+    /**
+     * Uninstall a ClawHub skill
+     */
+    uninstall(skillName) {
+        const index = this.state.installed.findIndex((s) => s.name === skillName);
+        if (index === -1) {
+            throw new Error(`Skill "${skillName}" is not installed from ClawHub`);
+        }
+        const skill = this.state.installed[index];
+        // Remove skill directory
+        if (existsSync(skill.localPath)) {
+            rmSync(skill.localPath, { recursive: true, force: true });
+        }
+        this.state.installed.splice(index, 1);
+        this.saveState();
+    }
+    /**
+     * List installed ClawHub skills
+     */
+    listInstalled() {
+        return [...this.state.installed];
+    }
+    /**
+     * Get featured/popular skills
+     */
+    async getFeatured() {
+        const all = await this.search();
+        return all.sort((a, b) => b.stars - a.stars).slice(0, 20);
+    }
+    // Private: GitHub Search
+    async searchGitHub(query) {
+        const skills = [];
+        const searchQuery = query
+            ? `SKILL.md ${query} in:path,file`
+            : 'SKILL.md openclaw in:path,file language:markdown';
+        try {
+            const url = `${GITHUB_API}/search/code?q=${encodeURIComponent(searchQuery)}&per_page=30`;
+            const response = await this.githubFetch(url);
+            if (!response.ok) {
+                // Rate limited or unauthorized - return empty
+                return skills;
+            }
+            const data = await response.json();
+            for (const item of data.items || []) {
+                // Only include SKILL.md files
+                if (!item.name.endsWith('SKILL.md'))
+                    continue;
+                // Extract skill name from path (parent directory name)
+                const pathParts = item.path.split('/');
+                const skillName = pathParts.length > 1
+                    ? pathParts[pathParts.length - 2]
+                    : item.repository.full_name.split('/')[1];
+                skills.push({
+                    name: skillName,
+                    description: item.repository.description || '',
+                    author: item.repository.owner.login,
+                    repo: item.repository.full_name,
+                    path: item.path,
+                    stars: item.repository.stargazers_count,
+                    lastUpdated: item.repository.updated_at,
+                    tags: [],
+                    source: 'github',
+                    installUrl: `https://raw.githubusercontent.com/${item.repository.full_name}/main/${item.path}`,
+                });
+            }
+        }
+        catch {
+            // GitHub search failed - return what we have
+        }
+        return skills;
+    }
+    async fetchAwesomeList() {
+        const skills = [];
+        try {
+            // Try to fetch from awesome-openclaw-skills repo
+            const url = `${GITHUB_API}/repos/VoltAgent/awesome-openclaw-skills/contents/README.md`;
+            const response = await this.githubFetch(url);
+            if (!response.ok)
+                return skills;
+            const data = await response.json();
+            if (!data.download_url)
+                return skills;
+            const content = await (await fetch(data.download_url)).text();
+            // Parse markdown links that look like skill references
+            // Pattern: - [Skill Name](url) - description
+            const linkRegex = /- \[([^\]]+)\]\(([^)]+)\)\s*[-:]?\s*(.*)/g;
+            let linkMatch;
+            while ((linkMatch = linkRegex.exec(content)) !== null) {
+                const [, name, repoUrl, description] = linkMatch;
+                if (!repoUrl.includes('github.com'))
+                    continue;
+                const repoParts = repoUrl.replace('https://github.com/', '').split('/');
+                if (repoParts.length < 2)
+                    continue;
+                skills.push({
+                    name: name.toLowerCase().replace(/\s+/g, '-'),
+                    description: description || name,
+                    author: repoParts[0],
+                    repo: `${repoParts[0]}/${repoParts[1]}`,
+                    path: 'SKILL.md',
+                    stars: 0,
+                    lastUpdated: '',
+                    tags: [],
+                    source: 'awesome-list',
+                    installUrl: `https://raw.githubusercontent.com/${repoParts[0]}/${repoParts[1]}/main/SKILL.md`,
+                });
+            }
+        }
+        catch {
+            // Awesome list fetch failed - that's fine
+        }
+        return skills;
+    }
+    async downloadSkillMd(skill) {
+        // Try the installUrl first
+        const urls = [
+            skill.installUrl,
+            `https://raw.githubusercontent.com/${skill.repo}/main/${skill.path}`,
+            `https://raw.githubusercontent.com/${skill.repo}/master/${skill.path}`,
+        ];
+        for (const url of urls) {
+            try {
+                const response = await fetch(url);
+                if (response.ok) {
+                    return await response.text();
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+        throw new Error(`Failed to download SKILL.md for ${skill.name} from ${skill.repo}`);
+    }
+    async githubFetch(url) {
+        const headers = {
+            Accept: 'application/vnd.github.v3+json',
+            'User-Agent': 'profclaw-clawhub-client',
+        };
+        if (this.githubToken) {
+            headers.Authorization = `Bearer ${this.githubToken}`;
+        }
+        return fetch(url, { headers });
+    }
+    // State persistence
+    loadState() {
+        try {
+            if (existsSync(CLAWHUB_STATE_FILE)) {
+                const data = readFileSync(CLAWHUB_STATE_FILE, 'utf-8');
+                return JSON.parse(data);
+            }
+        }
+        catch {
+            // Corrupted state, start fresh
+        }
+        return { installed: [], cache: [], lastSearch: null, cacheExpiry: null };
+    }
+    saveState() {
+        const dir = join(homedir(), '.profclaw');
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+        writeFileSync(CLAWHUB_STATE_FILE, JSON.stringify(this.state, null, 2));
+    }
+}
+// Singleton
+let client = null;
+export function getClawHubClient() {
+    if (!client) {
+        client = new ClawHubClient();
+    }
+    return client;
+}
+export { ClawHubClient };
+//# sourceMappingURL=clawhub.js.map

package/dist/plugins/loader.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Plugin Loader
+ *
+ * Discovers and loads profClaw plugins from:
+ * 1. ~/.profclaw/plugins/ (local plugins)
+ * 2. node_modules (npm packages with "profclaw" in package.json)
+ */
+import type { ProfClawPlugin } from './sdk.js';
+interface LoadedPlugin {
+    plugin: ProfClawPlugin;
+    source: 'local' | 'npm';
+    path: string;
+}
+/**
+ * Discover and load all available plugins.
+ */
+export declare function loadPlugins(): Promise<LoadedPlugin[]>;
+/**
+ * Get the plugins directory path.
+ */
+export declare function getPluginsDir(): string;
+export {};
+//# sourceMappingURL=loader.d.ts.map

package/dist/plugins/loader.js

@@ -0,0 +1,140 @@
+/**
+ * Plugin Loader
+ *
+ * Discovers and loads profClaw plugins from:
+ * 1. ~/.profclaw/plugins/ (local plugins)
+ * 2. node_modules (npm packages with "profclaw" in package.json)
+ */
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { logger } from '../utils/logger.js';
+import { hasCapability } from '../core/deployment.js';
+const PLUGINS_DIR = join(homedir(), '.profclaw', 'plugins');
+/**
+ * Discover and load all available plugins.
+ */
+export async function loadPlugins() {
+    if (!hasCapability('plugins')) {
+        logger.info('[Plugins] Plugin loading disabled in this mode');
+        return [];
+    }
+    const plugins = [];
+    // 1. Load from ~/.profclaw/plugins/
+    const localPlugins = await loadLocalPlugins();
+    plugins.push(...localPlugins);
+    // 2. Load from node_modules (profclaw-plugin-* packages)
+    const npmPlugins = await loadNpmPlugins();
+    plugins.push(...npmPlugins);
+    logger.info(`[Plugins] Loaded ${plugins.length} plugins (${localPlugins.length} local, ${npmPlugins.length} npm)`);
+    return plugins;
+}
+/**
+ * Load plugins from ~/.profclaw/plugins/
+ */
+async function loadLocalPlugins() {
+    const plugins = [];
+    if (!existsSync(PLUGINS_DIR))
+        return plugins;
+    const entries = readdirSync(PLUGINS_DIR, { withFileTypes: true });
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const pluginDir = join(PLUGINS_DIR, entry.name);
+        try {
+            const plugin = await loadPluginFromDir(pluginDir);
+            if (plugin) {
+                plugins.push({ plugin, source: 'local', path: pluginDir });
+                logger.info(`[Plugins] Loaded local plugin: ${plugin.metadata.name}`);
+            }
+        }
+        catch (error) {
+            logger.error(`[Plugins] Failed to load local plugin ${entry.name}:`, error);
+        }
+    }
+    return plugins;
+}
+/**
+ * Load plugins from node_modules.
+ */
+async function loadNpmPlugins() {
+    const plugins = [];
+    const nodeModulesDir = join(process.cwd(), 'node_modules');
+    if (!existsSync(nodeModulesDir))
+        return plugins;
+    // Look for packages matching profclaw-plugin-* pattern
+    const entries = readdirSync(nodeModulesDir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        // Check profclaw-plugin-* packages
+        if (entry.name.startsWith('profclaw-plugin-')) {
+            const packageDir = join(nodeModulesDir, entry.name);
+            try {
+                const plugin = await loadPluginFromDir(packageDir);
+                if (plugin) {
+                    plugins.push({ plugin, source: 'npm', path: packageDir });
+                    logger.info(`[Plugins] Loaded npm plugin: ${plugin.metadata.name}`);
+                }
+            }
+            catch (error) {
+                logger.error(`[Plugins] Failed to load npm plugin ${entry.name}:`, error);
+            }
+        }
+        // Check @profclaw/* scoped packages
+        if (entry.name === '@profclaw') {
+            const scopeDir = join(nodeModulesDir, entry.name);
+            const scopeEntries = readdirSync(scopeDir, { withFileTypes: true });
+            for (const scopeEntry of scopeEntries) {
+                if (!scopeEntry.isDirectory())
+                    continue;
+                const packageDir = join(scopeDir, scopeEntry.name);
+                try {
+                    const plugin = await loadPluginFromDir(packageDir);
+                    if (plugin) {
+                        plugins.push({ plugin, source: 'npm', path: packageDir });
+                        logger.info(`[Plugins] Loaded npm plugin: ${plugin.metadata.name}`);
+                    }
+                }
+                catch (error) {
+                    logger.error(`[Plugins] Failed to load npm plugin @profclaw/${scopeEntry.name}:`, error);
+                }
+            }
+        }
+    }
+    return plugins;
+}
+/**
+ * Load a single plugin from a directory.
+ */
+async function loadPluginFromDir(dir) {
+    const pkgPath = join(dir, 'package.json');
+    if (!existsSync(pkgPath))
+        return null;
+    const pkgContent = readFileSync(pkgPath, 'utf-8');
+    const pkg = JSON.parse(pkgContent);
+    // Must have profclaw config
+    if (!pkg.profclaw && !pkg.name?.includes('profclaw'))
+        return null;
+    const entryPoint = pkg.profclaw?.main || 'index.js';
+    const entryPath = join(dir, entryPoint);
+    if (!existsSync(entryPath)) {
+        logger.warn(`[Plugins] Entry point not found: ${entryPath}`);
+        return null;
+    }
+    const module = await import(entryPath);
+    const plugin = module.default || module;
+    // Validate plugin has required fields
+    if (!plugin.metadata?.id || !plugin.metadata?.name) {
+        logger.warn(`[Plugins] Plugin in ${dir} missing metadata.id or metadata.name`);
+        return null;
+    }
+    return plugin;
+}
+/**
+ * Get the plugins directory path.
+ */
+export function getPluginsDir() {
+    return PLUGINS_DIR;
+}
+//# sourceMappingURL=loader.js.map

package/dist/plugins/marketplace.d.ts

@@ -0,0 +1,77 @@
+/**
+ * profClaw Plugin Marketplace
+ *
+ * Discovers, installs, and manages plugins from the npm registry.
+ * Plugins can be published as `profclaw-plugin-*` or `@profclaw/plugin-*`.
+ */
+export interface MarketplacePlugin {
+    name: string;
+    version: string;
+    description: string;
+    author: string;
+    category: 'tool' | 'channel' | 'provider' | 'integration' | 'skill' | 'theme' | 'middleware';
+    downloads: number;
+    lastPublished: string;
+    homepage?: string;
+    repository?: string;
+    keywords: string[];
+    profclaw?: {
+        minVersion?: string;
+        capabilities?: string[];
+    };
+}
+export interface InstalledPlugin {
+    name: string;
+    version: string;
+    source: 'npm' | 'local';
+    path: string;
+    installedAt: string;
+    enabled: boolean;
+}
+declare class PluginMarketplace {
+    private state;
+    constructor();
+    /**
+     * Search npm registry for profClaw plugins
+     */
+    search(query?: string, category?: string): Promise<MarketplacePlugin[]>;
+    /**
+     * Install a plugin from npm
+     */
+    install(packageName: string, version?: string): Promise<InstalledPlugin>;
+    /**
+     * Uninstall a plugin
+     */
+    uninstall(packageName: string): Promise<void>;
+    /**
+     * Enable/disable a plugin
+     */
+    setEnabled(packageName: string, enabled: boolean): void;
+    /**
+     * List installed plugins
+     */
+    listInstalled(): InstalledPlugin[];
+    /**
+     * Get details of an installed plugin
+     */
+    getInstalled(packageName: string): InstalledPlugin | undefined;
+    /**
+     * Check for updates to installed plugins
+     */
+    checkUpdates(): Promise<Array<{
+        name: string;
+        current: string;
+        latest: string;
+    }>>;
+    /**
+     * Update a plugin to the latest version
+     */
+    update(packageName: string): Promise<InstalledPlugin>;
+    private inferCategory;
+    private detectPackageManager;
+    private loadState;
+    private saveState;
+}
+export declare function getMarketplace(): PluginMarketplace;
+export { PluginMarketplace };
+//# sourceMappingURL=marketplace.d.ts.map