profclaw 0.0.1-beta.1

package/dist/chat/providers/types.d.ts

@@ -0,0 +1,437 @@
+/**
+ * Chat Provider Types
+ *
+ * Unified abstraction for chat integrations (Slack, WhatsApp, Telegram, Discord, etc.)
+ * Inspired by OpenClaw's plugin architecture.
+ *
+ * Key concepts:
+ * - Providers implement adapters for different concerns (outbound, inbound, auth, etc.)
+ * - Capabilities advertise what a provider supports
+ * - Multi-account support from day one
+ * - Configuration-driven behavior
+ */
+import { z } from 'zod';
+export type ChatProviderId = 'slack' | 'discord' | 'telegram' | 'whatsapp' | 'webchat' | 'matrix' | 'googlechat' | 'msteams' | 'mattermost' | 'signal' | 'irc' | 'line' | 'dingtalk' | 'wecom' | 'feishu' | 'qq' | 'nostr' | 'twitch' | 'zalo' | 'nextcloud' | 'imessage' | 'synology' | 'tlon' | 'zalo-personal' | 'custom';
+export interface ChatProviderMeta {
+    id: ChatProviderId;
+    name: string;
+    description: string;
+    icon: string;
+    docsUrl?: string;
+    order: number;
+    color?: string;
+}
+export interface ChatProviderCapabilities {
+    /** Supported chat types */
+    chatTypes: Array<'direct' | 'group' | 'channel' | 'thread'>;
+    /** Can send messages */
+    send: boolean;
+    /** Can receive messages (webhooks/events) */
+    receive: boolean;
+    /** Supports slash commands */
+    slashCommands: boolean;
+    /** Supports interactive components (buttons, menus) */
+    interactiveComponents: boolean;
+    /** Supports emoji reactions */
+    reactions: boolean;
+    /** Supports message editing */
+    edit: boolean;
+    /** Supports message deletion */
+    delete: boolean;
+    /** Supports threaded replies */
+    threads: boolean;
+    /** Supports file/media attachments */
+    media: boolean;
+    /** Supports rich blocks (Block Kit, Adaptive Cards) */
+    richBlocks: boolean;
+    /** Supports OAuth installation */
+    oauth: boolean;
+    /** Supports webhooks for outbound */
+    webhooks: boolean;
+    /** Supports real-time socket connections */
+    realtime: boolean;
+}
+/** Base account config shared by all providers */
+export interface ChatAccountConfigBase {
+    id: string;
+    name?: string;
+    enabled?: boolean;
+    isDefault?: boolean;
+}
+/** Provider-specific account configs */
+export interface SlackAccountConfig extends ChatAccountConfigBase {
+    provider: 'slack';
+    mode?: 'socket' | 'http';
+    botToken?: string;
+    appToken?: string;
+    signingSecret?: string;
+    webhookUrl?: string;
+    teamId?: string;
+    teamName?: string;
+}
+export interface DiscordAccountConfig extends ChatAccountConfigBase {
+    provider: 'discord';
+    botToken?: string;
+    applicationId?: string;
+    publicKey?: string;
+    guildId?: string;
+}
+export interface TelegramAccountConfig extends ChatAccountConfigBase {
+    provider: 'telegram';
+    botToken?: string;
+    webhookUrl?: string;
+    webhookSecret?: string;
+}
+export interface WhatsAppAccountConfig extends ChatAccountConfigBase {
+    provider: 'whatsapp';
+    phoneNumberId?: string;
+    businessAccountId?: string;
+    accessToken?: string;
+    webhookVerifyToken?: string;
+}
+export interface WebChatAccountConfig extends ChatAccountConfigBase {
+    provider: 'webchat';
+    allowAnonymous?: boolean;
+    maxSessionsPerIp?: number;
+    sessionTimeoutMs?: number;
+}
+export interface MatrixAccountConfig extends ChatAccountConfigBase {
+    provider: 'matrix';
+    homeserverUrl?: string;
+    accessToken?: string;
+    userId?: string;
+    deviceId?: string;
+    enableEncryption?: boolean;
+    allowedRoomIds?: string[];
+}
+export interface GoogleChatAccountConfig extends ChatAccountConfigBase {
+    provider: 'googlechat';
+    serviceAccountKey?: string;
+    projectId?: string;
+    webhookUrl?: string;
+    allowedSpaceIds?: string[];
+}
+export interface MSTeamsAccountConfig extends ChatAccountConfigBase {
+    provider: 'msteams';
+    appId?: string;
+    appPassword?: string;
+    tenantId?: string;
+    allowedTeamIds?: string[];
+    allowedChannelIds?: string[];
+}
+export interface SignalAccountConfig extends ChatAccountConfigBase {
+    provider: 'signal';
+    signaldSocketPath?: string;
+    phoneNumber?: string;
+    allowedNumbers?: string[];
+}
+export interface IRCAccountConfig extends ChatAccountConfigBase {
+    provider: 'irc';
+    server?: string;
+    port?: number;
+    nick?: string;
+    password?: string;
+    channels?: string[];
+    useTLS?: boolean;
+}
+export interface LINEAccountConfig extends ChatAccountConfigBase {
+    provider: 'line';
+    channelAccessToken?: string;
+    channelSecret?: string;
+    webhookUrl?: string;
+}
+export interface MattermostAccountConfig extends ChatAccountConfigBase {
+    provider: 'mattermost';
+    serverUrl?: string;
+    botToken?: string;
+    webhookUrl?: string;
+    teamId?: string;
+    allowedChannelIds?: string[];
+}
+export interface DingTalkAccountConfig extends ChatAccountConfigBase {
+    provider: 'dingtalk';
+    appKey?: string;
+    appSecret?: string;
+    robotCode?: string;
+    webhookUrl?: string;
+    webhookSecret?: string;
+}
+export interface WeComAccountConfig extends ChatAccountConfigBase {
+    provider: 'wecom';
+    corpId?: string;
+    agentId?: string;
+    secret?: string;
+    token?: string;
+    encodingAESKey?: string;
+    webhookUrl?: string;
+}
+export interface FeishuAccountConfig extends ChatAccountConfigBase {
+    provider: 'feishu';
+    appId?: string;
+    appSecret?: string;
+    verificationToken?: string;
+    encryptKey?: string;
+}
+export interface QQAccountConfig extends ChatAccountConfigBase {
+    provider: 'qq';
+    appId?: string;
+    token?: string;
+    secret?: string;
+    sandboxMode?: boolean;
+}
+export interface NostrAccountConfig extends ChatAccountConfigBase {
+    provider: 'nostr';
+    privateKey?: string;
+    relayUrls?: string[];
+    allowedPubkeys?: string[];
+}
+export interface TwitchAccountConfig extends ChatAccountConfigBase {
+    provider: 'twitch';
+    oauthToken?: string;
+    clientId?: string;
+    nick?: string;
+    channels?: string[];
+}
+export interface ZaloAccountConfig extends ChatAccountConfigBase {
+    provider: 'zalo';
+    accessToken?: string;
+    refreshToken?: string;
+    oaId?: string;
+    secretKey?: string;
+}
+export interface NextcloudAccountConfig extends ChatAccountConfigBase {
+    provider: 'nextcloud';
+    serverUrl?: string;
+    username?: string;
+    password?: string;
+    token?: string;
+}
+export interface IMessageAccountConfig extends ChatAccountConfigBase {
+    provider: 'imessage';
+    blueBubblesUrl?: string;
+    blueBubblesPassword?: string;
+    allowedAddresses?: string[];
+}
+export interface SynologyAccountConfig extends ChatAccountConfigBase {
+    provider: 'synology';
+    serverUrl?: string;
+    incomingWebhookUrl?: string;
+    outgoingWebhookToken?: string;
+}
+export interface TlonAccountConfig extends ChatAccountConfigBase {
+    provider: 'tlon';
+    shipUrl?: string;
+    shipCode?: string;
+    shipName?: string;
+    channelPath?: string;
+}
+export interface ZaloPersonalAccountConfig extends ChatAccountConfigBase {
+    provider: 'zalo-personal';
+    accessToken?: string;
+    secretKey?: string;
+    userId?: string;
+}
+export type ChatAccountConfig = SlackAccountConfig | DiscordAccountConfig | TelegramAccountConfig | WhatsAppAccountConfig | WebChatAccountConfig | MatrixAccountConfig | GoogleChatAccountConfig | MSTeamsAccountConfig | SignalAccountConfig | IRCAccountConfig | LINEAccountConfig | MattermostAccountConfig | DingTalkAccountConfig | WeComAccountConfig | FeishuAccountConfig | QQAccountConfig | NostrAccountConfig | TwitchAccountConfig | ZaloAccountConfig | NextcloudAccountConfig | IMessageAccountConfig | SynologyAccountConfig | TlonAccountConfig | ZaloPersonalAccountConfig;
+export type ChatType = 'direct' | 'group' | 'channel' | 'thread';
+/** Normalized incoming message */
+export interface IncomingMessage {
+    id: string;
+    provider: ChatProviderId;
+    accountId: string;
+    senderId: string;
+    senderName: string;
+    senderUsername?: string;
+    chatType: ChatType;
+    chatId: string;
+    chatName?: string;
+    threadId?: string;
+    replyToId?: string;
+    text: string;
+    rawContent?: unknown;
+    timestamp: Date;
+    editedAt?: Date;
+    attachments?: MessageAttachment[];
+}
+export interface MessageAttachment {
+    type: 'file' | 'image' | 'video' | 'audio' | 'link';
+    url?: string;
+    name?: string;
+    mimeType?: string;
+    size?: number;
+}
+/** Outgoing message */
+export interface OutgoingMessage {
+    provider: ChatProviderId;
+    accountId?: string;
+    to: string;
+    chatType?: ChatType;
+    threadId?: string;
+    replyToId?: string;
+    text?: string;
+    blocks?: unknown[];
+    attachments?: OutgoingAttachment[];
+    ephemeral?: boolean;
+}
+export interface OutgoingAttachment {
+    type: 'file' | 'image';
+    url?: string;
+    data?: Buffer;
+    filename?: string;
+    mimeType?: string;
+}
+/** Slash command from a chat provider */
+export interface SlashCommand {
+    provider: ChatProviderId;
+    accountId: string;
+    command: string;
+    text: string;
+    userId: string;
+    userName: string;
+    channelId: string;
+    channelName?: string;
+    chatType: ChatType;
+    responseUrl?: string;
+    triggerId?: string;
+    raw: unknown;
+}
+/** Interactive component action (button click, menu select) */
+export interface InteractiveAction {
+    provider: ChatProviderId;
+    accountId: string;
+    type: 'button' | 'select' | 'overflow' | 'datepicker' | 'modal_submit';
+    actionId: string;
+    value?: string;
+    userId: string;
+    userName: string;
+    channelId?: string;
+    messageId?: string;
+    threadId?: string;
+    responseUrl?: string;
+    triggerId?: string;
+    raw: unknown;
+}
+export interface SendResult {
+    success: boolean;
+    messageId?: string;
+    threadId?: string;
+    error?: string;
+    raw?: unknown;
+}
+export interface CommandResponse {
+    responseType: 'ephemeral' | 'in_channel';
+    text?: string;
+    blocks?: unknown[];
+    attachments?: unknown[];
+}
+/** Authentication adapter */
+export interface AuthAdapter {
+    /** Get OAuth authorization URL */
+    getAuthUrl(state: string, scopes?: string[]): string;
+    /** Exchange code for tokens */
+    exchangeCode(code: string): Promise<{
+        accessToken: string;
+        refreshToken?: string;
+        expiresIn?: number;
+        teamId?: string;
+        teamName?: string;
+        botUserId?: string;
+    }>;
+    /** Refresh access token */
+    refreshToken?(refreshToken: string): Promise<{
+        accessToken: string;
+        refreshToken?: string;
+        expiresIn?: number;
+    }>;
+    /** Verify webhook signature */
+    verifyWebhook(signature: string, timestamp: string, body: string): boolean;
+}
+/** Outbound message adapter */
+export interface OutboundAdapter {
+    /** Send a message */
+    send(message: OutgoingMessage): Promise<SendResult>;
+    /** Edit a message */
+    edit?(messageId: string, channelId: string, content: OutgoingMessage): Promise<SendResult>;
+    /** Delete a message */
+    delete?(messageId: string, channelId: string): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    /** Add a reaction */
+    react?(messageId: string, channelId: string, emoji: string): Promise<{
+        success: boolean;
+    }>;
+    /** Remove a reaction */
+    unreact?(messageId: string, channelId: string, emoji: string): Promise<{
+        success: boolean;
+    }>;
+}
+/** Inbound message adapter */
+export interface InboundAdapter {
+    /** Parse webhook payload to normalized message */
+    parseMessage(payload: unknown): IncomingMessage | null;
+    /** Parse slash command payload */
+    parseCommand(payload: unknown): SlashCommand | null;
+    /** Parse interactive action payload */
+    parseAction(payload: unknown): InteractiveAction | null;
+    /** Build response for slash command */
+    buildCommandResponse(response: CommandResponse): unknown;
+    /** Build response for interactive action */
+    buildActionResponse?(response: CommandResponse): unknown;
+}
+/** Status/health adapter */
+export interface StatusAdapter {
+    /** Check if provider is configured */
+    isConfigured(config: ChatAccountConfig): boolean;
+    /** Check if provider is connected/healthy */
+    checkHealth(config: ChatAccountConfig): Promise<{
+        connected: boolean;
+        latencyMs?: number;
+        error?: string;
+        details?: Record<string, unknown>;
+    }>;
+}
+export interface ChatProvider<TConfig extends ChatAccountConfig = ChatAccountConfig> {
+    /** Provider metadata */
+    meta: ChatProviderMeta;
+    /** Declared capabilities */
+    capabilities: ChatProviderCapabilities;
+    /** Default configuration */
+    defaultConfig: Partial<TConfig>;
+    /** Configuration schema (Zod) */
+    configSchema: z.ZodType<TConfig>;
+    auth?: AuthAdapter;
+    outbound: OutboundAdapter;
+    inbound: InboundAdapter;
+    status: StatusAdapter;
+}
+export interface ProviderRegistry {
+    /** Register a provider */
+    register(provider: ChatProvider): void;
+    /** Get provider by ID */
+    get(id: ChatProviderId): ChatProvider | undefined;
+    /** List all registered providers */
+    list(): ChatProvider[];
+    /** Get providers with specific capability */
+    withCapability(capability: keyof ChatProviderCapabilities): ChatProvider[];
+}
+/** Context passed to handlers */
+export interface ChatContext {
+    provider: ChatProviderId;
+    accountId: string;
+    config: ChatAccountConfig;
+    chatId?: string;
+    chatType?: ChatType;
+    threadId?: string;
+    userId?: string;
+    userName?: string;
+}
+export type ChatEventType = 'message' | 'command' | 'action' | 'reaction_added' | 'reaction_removed' | 'member_joined' | 'member_left' | 'channel_created' | 'channel_deleted';
+export interface ChatEvent {
+    type: ChatEventType;
+    provider: ChatProviderId;
+    accountId: string;
+    timestamp: Date;
+    payload: IncomingMessage | SlashCommand | InteractiveAction | unknown;
+}
+export type ChatEventHandler = (event: ChatEvent, context: ChatContext) => Promise<void>;
+//# sourceMappingURL=types.d.ts.map

package/dist/chat/providers/types.js

@@ -0,0 +1,14 @@
+/**
+ * Chat Provider Types
+ *
+ * Unified abstraction for chat integrations (Slack, WhatsApp, Telegram, Discord, etc.)
+ * Inspired by OpenClaw's plugin architecture.
+ *
+ * Key concepts:
+ * - Providers implement adapters for different concerns (outbound, inbound, auth, etc.)
+ * - Capabilities advertise what a provider supports
+ * - Multi-account support from day one
+ * - Configuration-driven behavior
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/chat/providers/webchat/index.d.ts

@@ -0,0 +1,38 @@
+/**
+ * WebChat Provider
+ *
+ * Browser-based chat interface via SSE (Server-Sent Events).
+ * Enables zero-install access to profClaw from any browser.
+ * Session-based with optional anonymous access and rate limiting.
+ */
+import type { ChatProvider, WebChatAccountConfig } from '../types.js';
+interface WebChatSession {
+    id: string;
+    userId: string;
+    userName: string;
+    ip: string;
+    createdAt: Date;
+    lastActiveAt: Date;
+    controller: ReadableStreamDefaultController<Uint8Array> | null;
+}
+/** Create a new WebChat session. Returns session ID. */
+export declare function createSession(opts: {
+    userId?: string;
+    userName?: string;
+    ip: string;
+}): string;
+/** Get session by ID. */
+export declare function getSession(sessionId: string): WebChatSession | undefined;
+/** Attach SSE controller to a session. */
+export declare function attachSSE(sessionId: string, controller: ReadableStreamDefaultController<Uint8Array>): boolean;
+/** Send a message to a specific session via SSE. */
+export declare function sendToSession(sessionId: string, eventType: string, data: Record<string, unknown>): boolean;
+/** Remove a session. */
+export declare function removeSession(sessionId: string): void;
+/** Get active session count. */
+export declare function getSessionCount(): number;
+/** Count sessions per IP for rate limiting. */
+export declare function getSessionCountByIp(ip: string): number;
+export declare const webchatProvider: ChatProvider<WebChatAccountConfig>;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/chat/providers/webchat/index.js

@@ -0,0 +1,214 @@
+/**
+ * WebChat Provider
+ *
+ * Browser-based chat interface via SSE (Server-Sent Events).
+ * Enables zero-install access to profClaw from any browser.
+ * Session-based with optional anonymous access and rate limiting.
+ */
+import { z } from 'zod';
+import { randomUUID } from 'crypto';
+const sessions = new Map();
+const encoder = new TextEncoder();
+// Cleanup expired sessions every 5 minutes
+const SESSION_TIMEOUT_MS = 30 * 60 * 1000; // 30 minutes default
+setInterval(() => {
+    const now = Date.now();
+    for (const [id, session] of sessions) {
+        if (now - session.lastActiveAt.getTime() > SESSION_TIMEOUT_MS) {
+            if (session.controller) {
+                try {
+                    session.controller.close();
+                }
+                catch { /* already closed */ }
+            }
+            sessions.delete(id);
+        }
+    }
+}, 5 * 60 * 1000);
+// PUBLIC API
+/** Create a new WebChat session. Returns session ID. */
+export function createSession(opts) {
+    const sessionId = randomUUID();
+    sessions.set(sessionId, {
+        id: sessionId,
+        userId: opts.userId || `anon-${sessionId.slice(0, 8)}`,
+        userName: opts.userName || 'Anonymous',
+        ip: opts.ip,
+        createdAt: new Date(),
+        lastActiveAt: new Date(),
+        controller: null,
+    });
+    return sessionId;
+}
+/** Get session by ID. */
+export function getSession(sessionId) {
+    const session = sessions.get(sessionId);
+    if (session) {
+        session.lastActiveAt = new Date();
+    }
+    return session;
+}
+/** Attach SSE controller to a session. */
+export function attachSSE(sessionId, controller) {
+    const session = sessions.get(sessionId);
+    if (!session)
+        return false;
+    // Close previous connection if any
+    if (session.controller) {
+        try {
+            session.controller.close();
+        }
+        catch { /* ok */ }
+    }
+    session.controller = controller;
+    return true;
+}
+/** Send a message to a specific session via SSE. */
+export function sendToSession(sessionId, eventType, data) {
+    const session = sessions.get(sessionId);
+    if (!session?.controller)
+        return false;
+    try {
+        const msg = `event: ${eventType}\ndata: ${JSON.stringify(data)}\n\n`;
+        session.controller.enqueue(encoder.encode(msg));
+        return true;
+    }
+    catch {
+        // Connection closed
+        session.controller = null;
+        return false;
+    }
+}
+/** Remove a session. */
+export function removeSession(sessionId) {
+    const session = sessions.get(sessionId);
+    if (session?.controller) {
+        try {
+            session.controller.close();
+        }
+        catch { /* ok */ }
+    }
+    sessions.delete(sessionId);
+}
+/** Get active session count. */
+export function getSessionCount() {
+    return sessions.size;
+}
+/** Count sessions per IP for rate limiting. */
+export function getSessionCountByIp(ip) {
+    let count = 0;
+    for (const session of sessions.values()) {
+        if (session.ip === ip)
+            count++;
+    }
+    return count;
+}
+// WEBCHAT PROVIDER IMPLEMENTATION
+const meta = {
+    id: 'webchat',
+    name: 'WebChat',
+    description: 'Browser-based chat via SSE',
+    icon: 'message-circle',
+    order: 0,
+    color: '#6366f1',
+};
+const capabilities = {
+    chatTypes: ['direct'],
+    send: true,
+    receive: true,
+    slashCommands: false,
+    interactiveComponents: false,
+    reactions: false,
+    edit: false,
+    delete: false,
+    threads: false,
+    media: false,
+    richBlocks: false,
+    oauth: false,
+    webhooks: false,
+    realtime: true,
+};
+const outbound = {
+    async send(message) {
+        const sessionId = message.to;
+        const messageId = randomUUID();
+        const sent = sendToSession(sessionId, 'message', {
+            id: messageId,
+            text: message.text || '',
+            timestamp: new Date().toISOString(),
+            from: 'assistant',
+        });
+        if (!sent) {
+            return { success: false, error: 'Session not found or disconnected' };
+        }
+        return { success: true, messageId };
+    },
+};
+const inbound = {
+    parseMessage(payload) {
+        const data = payload;
+        if (!data?.sessionId || !data?.text)
+            return null;
+        const session = getSession(data.sessionId);
+        if (!session)
+            return null;
+        return {
+            id: randomUUID(),
+            provider: 'webchat',
+            accountId: 'default',
+            senderId: session.userId,
+            senderName: session.userName,
+            chatType: 'direct',
+            chatId: session.id,
+            text: data.text,
+            timestamp: new Date(),
+        };
+    },
+    parseCommand(_payload) {
+        return null; // WebChat doesn't support slash commands
+    },
+    parseAction(_payload) {
+        return null; // WebChat doesn't support interactive actions
+    },
+    buildCommandResponse(response) {
+        return { text: response.text };
+    },
+};
+const status = {
+    isConfigured(_config) {
+        return true; // WebChat is always available
+    },
+    async checkHealth(_config) {
+        return {
+            connected: true,
+            details: {
+                activeSessions: getSessionCount(),
+            },
+        };
+    },
+};
+const configSchema = z.object({
+    id: z.string(),
+    name: z.string().optional(),
+    enabled: z.boolean().optional(),
+    isDefault: z.boolean().optional(),
+    provider: z.literal('webchat'),
+    allowAnonymous: z.boolean().optional(),
+    maxSessionsPerIp: z.number().optional(),
+    sessionTimeoutMs: z.number().optional(),
+});
+export const webchatProvider = {
+    meta,
+    capabilities,
+    defaultConfig: {
+        provider: 'webchat',
+        allowAnonymous: true,
+        maxSessionsPerIp: 5,
+        sessionTimeoutMs: 30 * 60 * 1000,
+    },
+    configSchema,
+    outbound,
+    inbound,
+    status,
+};
+//# sourceMappingURL=index.js.map