profclaw 0.0.1-beta.1

package/dist/notifications/in-app.d.ts

@@ -0,0 +1,28 @@
+/**
+ * In-App Notification Service
+ *
+ * Creates DB notifications from task events so the bell dropdown populates.
+ */
+interface TaskNotificationEvent {
+    type: string;
+    taskId: string;
+    task: {
+        id: string;
+        title: string;
+        status: string;
+    };
+    result?: {
+        success: boolean;
+        error?: {
+            message?: string;
+        };
+    };
+}
+/**
+ * Write a notification row for a task event.
+ * Checks server-side notification prefs before writing.
+ * Returns the notification ID, or null if skipped.
+ */
+export declare function createTaskNotification(event: TaskNotificationEvent): Promise<string | null>;
+export {};
+//# sourceMappingURL=in-app.d.ts.map

package/dist/notifications/in-app.js

@@ -0,0 +1,53 @@
+/**
+ * In-App Notification Service
+ *
+ * Creates DB notifications from task events so the bell dropdown populates.
+ */
+import { randomUUID } from 'node:crypto';
+import { getClient } from '../storage/index.js';
+import { getSettingsRaw } from '../settings/index.js';
+import { logger } from '../utils/logger.js';
+/**
+ * Write a notification row for a task event.
+ * Checks server-side notification prefs before writing.
+ * Returns the notification ID, or null if skipped.
+ */
+export async function createTaskNotification(event) {
+    try {
+        const settings = await getSettingsRaw();
+        const prefs = settings.notifications;
+        // Respect user prefs
+        if (event.type === 'completed' && !prefs.taskComplete)
+            return null;
+        if (event.type === 'failed' && !prefs.taskFailed)
+            return null;
+        const id = randomUUID();
+        const client = getClient();
+        const isSuccess = event.type === 'completed';
+        const title = isSuccess
+            ? `Task completed: ${event.task.title}`
+            : `Task failed: ${event.task.title}`;
+        const description = isSuccess
+            ? null
+            : (event.result?.error?.message ?? 'Unknown error');
+        await client.execute({
+            sql: `INSERT INTO notifications (id, user_id, title, description, type, category, entity_type, entity_id) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+            args: [
+                id,
+                null,
+                title,
+                description,
+                isSuccess ? 'success' : 'error',
+                'task',
+                'task',
+                event.taskId,
+            ],
+        });
+        return id;
+    }
+    catch (error) {
+        logger.error('[Notifications] Failed to create task notification:', error instanceof Error ? error : undefined);
+        return null;
+    }
+}
+//# sourceMappingURL=in-app.js.map

package/dist/notifications/index.d.ts

@@ -0,0 +1,3 @@
+export { sendSlackNotification, notifyTaskStarted, notifyTaskCompleted, notifyTaskFailed, } from './slack.js';
+export { createTaskNotification } from './in-app.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/notifications/index.js

@@ -0,0 +1,3 @@
+export { sendSlackNotification, notifyTaskStarted, notifyTaskCompleted, notifyTaskFailed, } from './slack.js';
+export { createTaskNotification } from './in-app.js';
+//# sourceMappingURL=index.js.map

package/dist/notifications/push.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Web Push Notification Service
+ *
+ * Sends push notifications to subscribed clients (PWA, browser).
+ * Uses the Web Push protocol (VAPID).
+ */
+export interface PushSubscription {
+    id: string;
+    endpoint: string;
+    keys: {
+        p256dh: string;
+        auth: string;
+    };
+    userId?: string;
+    deviceName?: string;
+    createdAt: string;
+}
+export interface PushNotification {
+    title: string;
+    body: string;
+    tag?: string;
+    url?: string;
+    actions?: Array<{
+        action: string;
+        title: string;
+    }>;
+}
+declare class PushNotificationService {
+    private subscriptions;
+    private vapidKeys;
+    constructor();
+    /**
+     * Get VAPID public key (needed by clients to subscribe)
+     */
+    getPublicKey(): string;
+    /**
+     * Register a push subscription
+     */
+    subscribe(subscription: Omit<PushSubscription, 'id' | 'createdAt'>): PushSubscription;
+    /**
+     * Unregister a push subscription
+     */
+    unsubscribe(subscriptionId: string): void;
+    /**
+     * Send push notification to all subscribers
+     */
+    notifyAll(notification: PushNotification): Promise<{
+        sent: number;
+        failed: number;
+    }>;
+    /**
+     * Send push notification to a specific user
+     */
+    notifyUser(userId: string, notification: PushNotification): Promise<{
+        sent: number;
+        failed: number;
+    }>;
+    /**
+     * List all subscriptions
+     */
+    listSubscriptions(): PushSubscription[];
+    /**
+     * Get subscription count
+     */
+    getSubscriptionCount(): number;
+    private sendPush;
+    private ensureDir;
+    private loadSubscriptions;
+    private saveSubscriptions;
+    private loadOrGenerateVapidKeys;
+}
+export declare function getPushService(): PushNotificationService;
+export { PushNotificationService };
+//# sourceMappingURL=push.d.ts.map

package/dist/notifications/push.js

@@ -0,0 +1,175 @@
+/**
+ * Web Push Notification Service
+ *
+ * Sends push notifications to subscribed clients (PWA, browser).
+ * Uses the Web Push protocol (VAPID).
+ */
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import crypto from 'node:crypto';
+const PUSH_DIR = join(homedir(), '.profclaw', 'push');
+const SUBSCRIPTIONS_FILE = join(PUSH_DIR, 'subscriptions.json');
+const VAPID_FILE = join(PUSH_DIR, 'vapid.json');
+// Push Service
+class PushNotificationService {
+    subscriptions = [];
+    vapidKeys = null;
+    constructor() {
+        this.ensureDir();
+        this.loadSubscriptions();
+        this.loadOrGenerateVapidKeys();
+    }
+    /**
+     * Get VAPID public key (needed by clients to subscribe)
+     */
+    getPublicKey() {
+        if (!this.vapidKeys) {
+            throw new Error('VAPID keys not initialized');
+        }
+        return this.vapidKeys.publicKey;
+    }
+    /**
+     * Register a push subscription
+     */
+    subscribe(subscription) {
+        // Check if endpoint already registered
+        const existing = this.subscriptions.find((s) => s.endpoint === subscription.endpoint);
+        if (existing)
+            return existing;
+        const sub = {
+            ...subscription,
+            id: crypto.randomUUID(),
+            createdAt: new Date().toISOString(),
+        };
+        this.subscriptions.push(sub);
+        this.saveSubscriptions();
+        return sub;
+    }
+    /**
+     * Unregister a push subscription
+     */
+    unsubscribe(subscriptionId) {
+        this.subscriptions = this.subscriptions.filter((s) => s.id !== subscriptionId);
+        this.saveSubscriptions();
+    }
+    /**
+     * Send push notification to all subscribers
+     */
+    async notifyAll(notification) {
+        let sent = 0;
+        let failed = 0;
+        for (const sub of this.subscriptions) {
+            try {
+                await this.sendPush(sub, notification);
+                sent++;
+            }
+            catch {
+                failed++;
+                // Remove invalid subscriptions (410 Gone)
+            }
+        }
+        return { sent, failed };
+    }
+    /**
+     * Send push notification to a specific user
+     */
+    async notifyUser(userId, notification) {
+        const userSubs = this.subscriptions.filter((s) => s.userId === userId);
+        let sent = 0;
+        let failed = 0;
+        for (const sub of userSubs) {
+            try {
+                await this.sendPush(sub, notification);
+                sent++;
+            }
+            catch {
+                failed++;
+            }
+        }
+        return { sent, failed };
+    }
+    /**
+     * List all subscriptions
+     */
+    listSubscriptions() {
+        return [...this.subscriptions];
+    }
+    /**
+     * Get subscription count
+     */
+    getSubscriptionCount() {
+        return this.subscriptions.length;
+    }
+    // Private
+    async sendPush(subscription, notification) {
+        const payload = JSON.stringify(notification);
+        // Use native fetch to send to the push endpoint
+        // In production, use web-push library for proper VAPID signing
+        // This is a simplified implementation
+        const response = await fetch(subscription.endpoint, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'TTL': '86400',
+            },
+            body: payload,
+        });
+        if (!response.ok) {
+            if (response.status === 410) {
+                // Subscription expired, remove it
+                this.unsubscribe(subscription.id);
+            }
+            throw new Error(`Push failed: ${response.status}`);
+        }
+    }
+    ensureDir() {
+        if (!existsSync(PUSH_DIR)) {
+            mkdirSync(PUSH_DIR, { recursive: true });
+        }
+    }
+    loadSubscriptions() {
+        try {
+            if (existsSync(SUBSCRIPTIONS_FILE)) {
+                const data = readFileSync(SUBSCRIPTIONS_FILE, 'utf-8');
+                this.subscriptions = JSON.parse(data);
+            }
+        }
+        catch {
+            this.subscriptions = [];
+        }
+    }
+    saveSubscriptions() {
+        writeFileSync(SUBSCRIPTIONS_FILE, JSON.stringify(this.subscriptions, null, 2));
+    }
+    loadOrGenerateVapidKeys() {
+        try {
+            if (existsSync(VAPID_FILE)) {
+                const data = readFileSync(VAPID_FILE, 'utf-8');
+                this.vapidKeys = JSON.parse(data);
+                return;
+            }
+        }
+        catch {
+            // Generate new keys
+        }
+        // Generate VAPID keys using ECDH with prime256v1
+        const ecdh = crypto.createECDH('prime256v1');
+        ecdh.generateKeys();
+        this.vapidKeys = {
+            publicKey: ecdh.getPublicKey('base64url'),
+            privateKey: ecdh.getPrivateKey('base64url'),
+        };
+        writeFileSync(VAPID_FILE, JSON.stringify(this.vapidKeys, null, 2));
+    }
+}
+// Singleton
+let pushService = null;
+export function getPushService() {
+    if (!pushService) {
+        pushService = new PushNotificationService();
+    }
+    return pushService;
+}
+export { PushNotificationService };
+//# sourceMappingURL=push.js.map

package/dist/notifications/slack.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Slack Notifications
+ *
+ * Sends notifications to Slack via incoming webhooks.
+ */
+import type { Task } from '../types/task.js';
+interface SlackNotification {
+    type: 'task_started' | 'task_completed' | 'task_failed' | 'task_retry' | 'agent_unhealthy' | 'agent_recovered';
+    title: string;
+    message: string;
+    task?: Task;
+    agent?: string;
+    severity?: 'info' | 'warning' | 'error' | 'success';
+}
+/**
+ * Send a notification to Slack
+ */
+export declare function sendSlackNotification(notification: SlackNotification): Promise<void>;
+/**
+ * Send task started notification
+ */
+export declare function notifyTaskStarted(task: Task): Promise<void>;
+/**
+ * Send task completed notification
+ */
+export declare function notifyTaskCompleted(task: Task, prUrl?: string): Promise<void>;
+/**
+ * Send task failed notification
+ */
+export declare function notifyTaskFailed(task: Task, error: string): Promise<void>;
+export {};
+//# sourceMappingURL=slack.d.ts.map

package/dist/notifications/slack.js

@@ -0,0 +1,157 @@
+/**
+ * Slack Notifications
+ *
+ * Sends notifications to Slack via incoming webhooks.
+ */
+const SLACK_WEBHOOK_URL = process.env.SLACK_WEBHOOK_URL || '';
+const SLACK_CHANNEL = process.env.SLACK_CHANNEL || '';
+const NOTIFY_ON_START = process.env.SLACK_NOTIFY_ON_START === 'true';
+const NOTIFY_ON_SUCCESS = process.env.SLACK_NOTIFY_ON_SUCCESS !== 'false'; // Default true
+const NOTIFY_ON_FAILURE = process.env.SLACK_NOTIFY_ON_FAILURE !== 'false'; // Default true
+/**
+ * Send a notification to Slack
+ */
+export async function sendSlackNotification(notification) {
+    if (!SLACK_WEBHOOK_URL) {
+        return; // Slack not configured
+    }
+    // Check if we should send this type of notification
+    if (notification.type === 'task_started' && !NOTIFY_ON_START)
+        return;
+    if (notification.type === 'task_completed' && !NOTIFY_ON_SUCCESS)
+        return;
+    if (notification.type === 'task_failed' && !NOTIFY_ON_FAILURE)
+        return;
+    const color = getColorForSeverity(notification.severity || 'info');
+    const blocks = [
+        {
+            type: 'header',
+            text: {
+                type: 'plain_text',
+                text: notification.title,
+                emoji: true,
+            },
+        },
+        {
+            type: 'section',
+            text: {
+                type: 'mrkdwn',
+                text: notification.message,
+            },
+        },
+    ];
+    // Add task details if present
+    if (notification.task) {
+        const task = notification.task;
+        const fields = [
+            { type: 'mrkdwn', text: `*Task ID:*\n\`${task.id.substring(0, 8)}...\`` },
+            { type: 'mrkdwn', text: `*Priority:*\n${getPriorityLabel(task.priority)}` },
+        ];
+        if (task.repository) {
+            fields.push({ type: 'mrkdwn', text: `*Repository:*\n${task.repository}` });
+        }
+        if (task.sourceUrl) {
+            fields.push({ type: 'mrkdwn', text: `*Source:*\n<${task.sourceUrl}|View Issue>` });
+        }
+        blocks.push({
+            type: 'section',
+            fields,
+        });
+    }
+    // Add timestamp
+    blocks.push({
+        type: 'context',
+        elements: [
+            {
+                type: 'mrkdwn',
+                text: `<!date^${Math.floor(Date.now() / 1000)}^{date_short_pretty} at {time}|${new Date().toISOString()}>`,
+            },
+        ],
+    });
+    const payload = {
+        channel: SLACK_CHANNEL || undefined,
+        attachments: [
+            {
+                color,
+                blocks,
+            },
+        ],
+    };
+    try {
+        const response = await fetch(SLACK_WEBHOOK_URL, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(payload),
+        });
+        if (!response.ok) {
+            console.error(`[Slack] Failed to send notification: ${response.status}`);
+        }
+    }
+    catch (error) {
+        console.error('[Slack] Error sending notification:', error);
+    }
+}
+/**
+ * Send task started notification
+ */
+export async function notifyTaskStarted(task) {
+    await sendSlackNotification({
+        type: 'task_started',
+        title: `🚀 Task Started: ${task.title}`,
+        message: `AI agent is now working on this task.`,
+        task,
+        severity: 'info',
+    });
+}
+/**
+ * Send task completed notification
+ */
+export async function notifyTaskCompleted(task, prUrl) {
+    let message = `Task completed successfully.`;
+    if (prUrl) {
+        message += `\n\n<${prUrl}|View Pull Request>`;
+    }
+    await sendSlackNotification({
+        type: 'task_completed',
+        title: `✅ Task Completed: ${task.title}`,
+        message,
+        task,
+        severity: 'success',
+    });
+}
+/**
+ * Send task failed notification
+ */
+export async function notifyTaskFailed(task, error) {
+    await sendSlackNotification({
+        type: 'task_failed',
+        title: `❌ Task Failed: ${task.title}`,
+        message: `Task failed with error:\n\`\`\`${error}\`\`\``,
+        task,
+        severity: 'error',
+    });
+}
+/**
+ * Get color for severity level
+ */
+function getColorForSeverity(severity) {
+    switch (severity) {
+        case 'success': return '#36a64f'; // Green
+        case 'warning': return '#f2c744'; // Yellow
+        case 'error': return '#dc3545'; // Red
+        default: return '#2196f3'; // Blue
+    }
+}
+/**
+ * Get human-readable priority label
+ */
+function getPriorityLabel(priority) {
+    switch (priority) {
+        case 1: return '🔴 Critical';
+        case 2: return '🟠 High';
+        case 3: return '🟡 Medium';
+        case 4: return '🟢 Low';
+        default: return '⚪ Unknown';
+    }
+}
+//# sourceMappingURL=slack.js.map

package/dist/plugins/clawhub.d.ts

@@ -0,0 +1,70 @@
+/**
+ * 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.
+ */
+export interface ClawHubSkill {
+    name: string;
+    description: string;
+    author: string;
+    repo: string;
+    path: string;
+    stars: number;
+    lastUpdated: string;
+    tags: string[];
+    source: 'clawhub' | 'github' | 'awesome-list';
+    installUrl: string;
+}
+export interface ClawHubInstalledSkill {
+    name: string;
+    repo: string;
+    installedAt: string;
+    localPath: string;
+    version?: string;
+}
+interface GitHubRepoContent {
+    name: string;
+    path: string;
+    type: 'file' | 'dir';
+    download_url: string | null;
+}
+declare class ClawHubClient {
+    private state;
+    private githubToken;
+    constructor();
+    /**
+     * Search for OpenClaw-compatible skills on GitHub
+     */
+    search(query?: string): Promise<ClawHubSkill[]>;
+    /**
+     * Install a skill from ClawHub/GitHub into ~/.profclaw/skills/
+     */
+    install(skill: ClawHubSkill): Promise<ClawHubInstalledSkill>;
+    /**
+     * Uninstall a ClawHub skill
+     */
+    uninstall(skillName: string): void;
+    /**
+     * List installed ClawHub skills
+     */
+    listInstalled(): ClawHubInstalledSkill[];
+    /**
+     * Get featured/popular skills
+     */
+    getFeatured(): Promise<ClawHubSkill[]>;
+    private searchGitHub;
+    private fetchAwesomeList;
+    private downloadSkillMd;
+    private githubFetch;
+    private loadState;
+    private saveState;
+}
+export declare function getClawHubClient(): ClawHubClient;
+export { ClawHubClient };
+export type { GitHubRepoContent };
+//# sourceMappingURL=clawhub.d.ts.map