profclaw 0.0.1-beta.1

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

@@ -0,0 +1,113 @@
+/**
+ * LINE Provider - Full Implementation
+ *
+ * LINE Messaging API integration using:
+ * - Channel access token authentication (Bearer)
+ * - HMAC-SHA256 signature verification (channelSecret)
+ * - Push messages to user/group/room IDs
+ * - Reply messages via replyToken (within 30s of event)
+ * - Media support: images, video, audio, files
+ * - Health check via GET /v2/bot/info
+ * - Webhook events: message, follow, unfollow, join, leave, etc.
+ *
+ * API base: https://api.line.me/v2/bot
+ * Docs: https://developers.line.biz/en/docs/messaging-api/
+ */
+import { z } from 'zod';
+import type { ChatProvider, LINEAccountConfig, SendResult, IncomingMessage } from '../types.js';
+/** LINE message types */
+declare const LINEMsgType: {
+    readonly TEXT: "text";
+    readonly IMAGE: "image";
+    readonly VIDEO: "video";
+    readonly AUDIO: "audio";
+    readonly FILE: "file";
+    readonly LOCATION: "location";
+    readonly STICKER: "sticker";
+    readonly FLEX: "flex";
+};
+type LINEMsgTypeValue = (typeof LINEMsgType)[keyof typeof LINEMsgType];
+/** LINE event source types */
+declare const LINESourceType: {
+    readonly USER: "user";
+    readonly GROUP: "group";
+    readonly ROOM: "room";
+};
+interface LINESource {
+    type: 'user' | 'group' | 'room';
+    userId?: string;
+    groupId?: string;
+    roomId?: string;
+}
+interface LINEMessageContent {
+    id: string;
+    type: LINEMsgTypeValue;
+    text?: string;
+    fileName?: string;
+    fileSize?: number;
+    duration?: number;
+    originalContentUrl?: string;
+    previewImageUrl?: string;
+}
+interface LINEEvent {
+    type: string;
+    message?: LINEMessageContent;
+    timestamp: number;
+    source: LINESource;
+    replyToken?: string;
+    mode: 'active' | 'standby';
+    webhookEventId?: string;
+    deliveryContext?: {
+        isRedelivery: boolean;
+    };
+}
+interface LINEWebhookBody {
+    destination: string;
+    events: LINEEvent[];
+}
+export declare const LINEAccountConfigSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    isDefault: z.ZodOptional<z.ZodBoolean>;
+    provider: z.ZodLiteral<"line">;
+    channelAccessToken: z.ZodOptional<z.ZodString>;
+    channelSecret: z.ZodOptional<z.ZodString>;
+    webhookUrl: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    provider: "line";
+    enabled: boolean;
+    name?: string | undefined;
+    isDefault?: boolean | undefined;
+    webhookUrl?: string | undefined;
+    channelAccessToken?: string | undefined;
+    channelSecret?: string | undefined;
+}, {
+    id: string;
+    provider: "line";
+    name?: string | undefined;
+    isDefault?: boolean | undefined;
+    enabled?: boolean | undefined;
+    webhookUrl?: string | undefined;
+    channelAccessToken?: string | undefined;
+    channelSecret?: string | undefined;
+}>;
+type LINEConfig = z.infer<typeof LINEAccountConfigSchema>;
+/**
+ * Parse all message events from a LINE webhook body.
+ * Returns normalized IncomingMessage objects for supported event types.
+ */
+export declare function parseLINEWebhook(webhookBody: LINEWebhookBody): IncomingMessage[];
+/**
+ * Send a reply message using a replyToken from a LINE webhook event.
+ * Reply tokens are valid for 30 seconds after the event is received.
+ * Using reply tokens is more cost-efficient than push messages.
+ */
+export declare function replyMessage(replyToken: string, text: string, config?: LINEConfig | null): Promise<SendResult>;
+export declare function setLINEConfig(config: LINEConfig): void;
+export declare function clearLINEConfig(): void;
+export declare const lineProvider: ChatProvider<LINEAccountConfig>;
+export type { LINEConfig, LINEEvent, LINESource, LINEMessageContent, LINEWebhookBody };
+export { LINEMsgType, LINESourceType };
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,434 @@
+/**
+ * LINE Provider - Full Implementation
+ *
+ * LINE Messaging API integration using:
+ * - Channel access token authentication (Bearer)
+ * - HMAC-SHA256 signature verification (channelSecret)
+ * - Push messages to user/group/room IDs
+ * - Reply messages via replyToken (within 30s of event)
+ * - Media support: images, video, audio, files
+ * - Health check via GET /v2/bot/info
+ * - Webhook events: message, follow, unfollow, join, leave, etc.
+ *
+ * API base: https://api.line.me/v2/bot
+ * Docs: https://developers.line.biz/en/docs/messaging-api/
+ */
+import { createHmac } from 'node:crypto';
+import { z } from 'zod';
+import { logger } from '../../../utils/logger.js';
+// LINE API TYPES
+/** LINE message types */
+const LINEMsgType = {
+    TEXT: 'text',
+    IMAGE: 'image',
+    VIDEO: 'video',
+    AUDIO: 'audio',
+    FILE: 'file',
+    LOCATION: 'location',
+    STICKER: 'sticker',
+    FLEX: 'flex',
+};
+/** LINE event source types */
+const LINESourceType = {
+    USER: 'user',
+    GROUP: 'group',
+    ROOM: 'room',
+};
+// CONFIGURATION
+export const LINEAccountConfigSchema = z.object({
+    id: z.string(),
+    name: z.string().optional(),
+    enabled: z.boolean().default(true),
+    isDefault: z.boolean().optional(),
+    provider: z.literal('line'),
+    channelAccessToken: z.string().optional(),
+    channelSecret: z.string().optional(),
+    webhookUrl: z.string().url().optional(),
+});
+// METADATA
+const meta = {
+    id: 'line',
+    name: 'LINE',
+    description: 'LINE Messaging API with push and reply message support',
+    icon: 'LINE icon',
+    docsUrl: 'https://developers.line.biz/en/docs/messaging-api/',
+    order: 11,
+    color: '#06C755',
+};
+// CAPABILITIES
+const capabilities = {
+    chatTypes: ['direct', 'group'],
+    send: true,
+    receive: true,
+    slashCommands: false,
+    interactiveComponents: false,
+    reactions: false,
+    edit: false,
+    delete: false,
+    threads: false,
+    media: true,
+    richBlocks: false, // Flex Messages deferred
+    oauth: false,
+    webhooks: true,
+    realtime: false,
+};
+// STATE
+let currentConfig = null;
+const LINE_API_BASE = 'https://api.line.me/v2/bot';
+// HELPER FUNCTIONS
+function getAuthHeaders(config) {
+    const token = (config ?? currentConfig)?.channelAccessToken;
+    return {
+        'Authorization': token ? `Bearer ${token}` : '',
+        'Content-Type': 'application/json',
+    };
+}
+async function callLINEApi(endpoint, method = 'GET', body, config) {
+    const headers = getAuthHeaders(config);
+    if (!headers['Authorization'] || headers['Authorization'] === 'Bearer ') {
+        return { ok: false, error: 'Channel access token not configured' };
+    }
+    const url = `${LINE_API_BASE}${endpoint}`;
+    try {
+        const response = await fetch(url, {
+            method,
+            headers,
+            body: body !== undefined ? JSON.stringify(body) : undefined,
+        });
+        if (response.status === 200 && method === 'POST') {
+            // LINE push/reply returns 200 with an empty body or sentMessages
+            const text = await response.text();
+            if (!text || text === '{}') {
+                return { ok: true, status: 200 };
+            }
+            try {
+                const data = JSON.parse(text);
+                return { ok: true, data, status: 200 };
+            }
+            catch {
+                return { ok: true, status: 200 };
+            }
+        }
+        const data = await response.json();
+        if (!response.ok) {
+            const errData = data;
+            return {
+                ok: false,
+                status: response.status,
+                error: errData.message ?? `HTTP ${response.status}`,
+            };
+        }
+        return { ok: true, data, status: response.status };
+    }
+    catch (error) {
+        logger.error('[LINE] API call failed:', error instanceof Error ? error : undefined);
+        return {
+            ok: false,
+            error: error instanceof Error ? error.message : 'Unknown error',
+        };
+    }
+}
+/**
+ * Derive the chat type from a LINE event source.
+ * Group and room sources map to 'group'; user sources map to 'direct'.
+ */
+function getLineChatType(source) {
+    if (source.type === LINESourceType.GROUP || source.type === LINESourceType.ROOM) {
+        return 'group';
+    }
+    return 'direct';
+}
+/**
+ * Resolve the chat ID from a LINE event source.
+ * Groups use groupId, rooms use roomId, direct uses userId.
+ */
+function getChatId(source) {
+    if (source.type === LINESourceType.GROUP && source.groupId) {
+        return source.groupId;
+    }
+    if (source.type === LINESourceType.ROOM && source.roomId) {
+        return source.roomId;
+    }
+    return source.userId ?? '';
+}
+/**
+ * Map LINE message type to attachment type for media messages.
+ */
+function lineTypeToAttachmentType(msgType) {
+    const map = {
+        [LINEMsgType.IMAGE]: 'image',
+        [LINEMsgType.VIDEO]: 'video',
+        [LINEMsgType.AUDIO]: 'audio',
+        [LINEMsgType.FILE]: 'file',
+    };
+    return map[msgType] ?? null;
+}
+// AUTH ADAPTER
+const authAdapter = {
+    getAuthUrl(_state, _scopes) {
+        // LINE Messaging API does not use OAuth for bot authentication.
+        // Channel access tokens are issued via the LINE Developers Console
+        // or via the Channel Access Token API.
+        throw new Error('LINE does not use OAuth for bot authentication. ' +
+            'Issue a channel access token via the LINE Developers Console ' +
+            'and supply it in the configuration.');
+    },
+    async exchangeCode(_code) {
+        throw new Error('LINE does not use OAuth authorization codes for bot authentication. ' +
+            'Use the LINE Channel Access Token API or the Developers Console.');
+    },
+    verifyWebhook(signature, _timestamp, body) {
+        // LINE uses HMAC-SHA256 of the raw request body with the channelSecret.
+        // The resulting digest is base64-encoded and sent in the X-Line-Signature header.
+        const secret = currentConfig?.channelSecret;
+        if (!secret) {
+            logger.warn('[LINE] verifyWebhook: channelSecret not configured, skipping verification');
+            return false;
+        }
+        try {
+            const expected = createHmac('sha256', secret)
+                .update(body, 'utf8')
+                .digest('base64');
+            return signature === expected;
+        }
+        catch (error) {
+            logger.error('[LINE] verifyWebhook: HMAC computation failed:', error instanceof Error ? error : undefined);
+            return false;
+        }
+    },
+};
+// OUTBOUND ADAPTER
+const outboundAdapter = {
+    async send(message) {
+        if (!currentConfig?.channelAccessToken) {
+            return { success: false, error: 'Channel access token not configured' };
+        }
+        if (!message.to) {
+            return { success: false, error: 'Target user ID or group ID (to) is required' };
+        }
+        const lineMessage = {
+            type: LINEMsgType.TEXT,
+            text: message.text ?? '',
+        };
+        // LINE push message: send to any user/group/room at any time
+        const pushBody = {
+            to: message.to,
+            messages: [lineMessage],
+        };
+        const result = await callLINEApi('/message/push', 'POST', pushBody);
+        if (result.ok) {
+            const messageId = result.data?.sentMessages?.[0]?.id;
+            return {
+                success: true,
+                messageId,
+            };
+        }
+        return {
+            success: false,
+            error: result.error ?? 'Failed to send message',
+        };
+    },
+};
+// INBOUND ADAPTER
+const inboundAdapter = {
+    parseMessage(payload) {
+        // Accepts a single LINEEvent or a LINEWebhookBody with events[].
+        // The webhook body has { destination, events[] }; individual event dispatch
+        // is handled by parseLINEWebhook() below. Here we accept either form.
+        let event;
+        if (payload !== null &&
+            typeof payload === 'object' &&
+            'events' in payload) {
+            // Full webhook body - parse first message event only
+            const webhookBody = payload;
+            const first = webhookBody.events.find((e) => e.type === 'message');
+            if (!first)
+                return null;
+            event = first;
+        }
+        else {
+            event = payload;
+        }
+        if (!event || event.type !== 'message')
+            return null;
+        const msg = event.message;
+        if (!msg)
+            return null;
+        // Supported message types for normalization
+        const supportedTypes = [
+            LINEMsgType.TEXT,
+            LINEMsgType.IMAGE,
+            LINEMsgType.VIDEO,
+            LINEMsgType.AUDIO,
+            LINEMsgType.FILE,
+        ];
+        if (!supportedTypes.includes(msg.type)) {
+            logger.debug(`[LINE] parseMessage: unsupported message type '${msg.type}', skipping`);
+            return null;
+        }
+        const source = event.source;
+        const senderId = source.userId ?? '';
+        const chatType = getLineChatType(source);
+        const chatId = getChatId(source);
+        const attachments = [];
+        const attachType = lineTypeToAttachmentType(msg.type);
+        if (attachType) {
+            // LINE media content is fetched via GET /v2/bot/message/{messageId}/content
+            // We record the content endpoint URL as the attachment URL for downstream fetching.
+            attachments.push({
+                type: attachType,
+                url: `${LINE_API_BASE}/message/${msg.id}/content`,
+                name: msg.fileName,
+                size: msg.fileSize,
+            });
+        }
+        return {
+            id: msg.id,
+            provider: 'line',
+            accountId: currentConfig?.id ?? 'default',
+            senderId,
+            senderName: senderId, // Display name requires separate GET /v2/bot/profile/{userId}
+            senderUsername: senderId,
+            chatType,
+            chatId,
+            chatName: undefined, // Resolved separately via LINE group/room profile API
+            threadId: undefined, // LINE does not support threads
+            replyToId: undefined,
+            text: msg.text ?? '',
+            rawContent: event,
+            timestamp: new Date(event.timestamp),
+            attachments: attachments.length > 0 ? attachments : undefined,
+        };
+    },
+    parseCommand(_payload) {
+        // LINE does not have native slash commands.
+        // Command-like behavior is implemented at the application layer
+        // by inspecting message text for prefix patterns (e.g., "/command").
+        return null;
+    },
+    parseAction(_payload) {
+        // LINE postback actions (button taps) are handled as separate event types
+        // ('postback') and are not normalized here. Full postback support is deferred.
+        return null;
+    },
+    buildCommandResponse(response) {
+        // Returns a LINE message object ready for use in a push or reply body.
+        return {
+            type: LINEMsgType.TEXT,
+            text: response.text ?? '',
+        };
+    },
+    buildActionResponse(response) {
+        return {
+            type: LINEMsgType.TEXT,
+            text: response.text ?? '',
+        };
+    },
+};
+// STATUS ADAPTER
+const statusAdapter = {
+    isConfigured(config) {
+        return !!(config.channelAccessToken && config.channelSecret);
+    },
+    async checkHealth(config) {
+        if (!config.channelAccessToken) {
+            return { connected: false, error: 'channelAccessToken is required' };
+        }
+        const lineConfig = {
+            id: config.id,
+            name: config.name,
+            enabled: config.enabled ?? true,
+            isDefault: config.isDefault,
+            provider: 'line',
+            channelAccessToken: config.channelAccessToken,
+            channelSecret: config.channelSecret,
+            webhookUrl: config.webhookUrl,
+        };
+        const start = Date.now();
+        const result = await callLINEApi('/info', 'GET', undefined, lineConfig);
+        const latencyMs = Date.now() - start;
+        if (result.ok && result.data) {
+            return {
+                connected: true,
+                latencyMs,
+                details: {
+                    userId: result.data.userId,
+                    basicId: result.data.basicId,
+                    displayName: result.data.displayName,
+                    chatMode: result.data.chatMode,
+                    webhookConfigured: !!config.webhookUrl,
+                    signatureVerificationEnabled: !!config.channelSecret,
+                },
+            };
+        }
+        return {
+            connected: false,
+            latencyMs,
+            error: result.error ?? 'Failed to connect to LINE Messaging API',
+        };
+    },
+};
+// EXPORTED HELPERS
+/**
+ * Parse all message events from a LINE webhook body.
+ * Returns normalized IncomingMessage objects for supported event types.
+ */
+export function parseLINEWebhook(webhookBody) {
+    const messages = [];
+    for (const event of webhookBody.events) {
+        if (event.type !== 'message')
+            continue;
+        const parsed = inboundAdapter.parseMessage(event);
+        if (parsed) {
+            messages.push(parsed);
+        }
+    }
+    return messages;
+}
+/**
+ * Send a reply message using a replyToken from a LINE webhook event.
+ * Reply tokens are valid for 30 seconds after the event is received.
+ * Using reply tokens is more cost-efficient than push messages.
+ */
+export async function replyMessage(replyToken, text, config) {
+    const effectiveConfig = config ?? currentConfig;
+    if (!effectiveConfig?.channelAccessToken) {
+        return { success: false, error: 'Channel access token not configured' };
+    }
+    const replyBody = {
+        replyToken,
+        messages: [{ type: LINEMsgType.TEXT, text }],
+    };
+    const result = await callLINEApi('/message/reply', 'POST', replyBody, effectiveConfig);
+    if (result.ok) {
+        const messageId = result.data?.sentMessages?.[0]?.id;
+        return { success: true, messageId };
+    }
+    return {
+        success: false,
+        error: result.error ?? 'Failed to send reply message',
+    };
+}
+// CONFIG MANAGEMENT
+export function setLINEConfig(config) {
+    currentConfig = config;
+}
+export function clearLINEConfig() {
+    currentConfig = null;
+}
+// PROVIDER EXPORT
+export const lineProvider = {
+    meta,
+    capabilities,
+    defaultConfig: {
+        provider: 'line',
+        enabled: true,
+    },
+    configSchema: LINEAccountConfigSchema,
+    auth: authAdapter,
+    outbound: outboundAdapter,
+    inbound: inboundAdapter,
+    status: statusAdapter,
+};
+export { LINEMsgType, LINESourceType };
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,161 @@
+/**
+ * Matrix Provider - Full Implementation
+ *
+ * Matrix Client-Server API v1.x integration using:
+ * - Bearer token authentication (access token)
+ * - Room-based messaging (direct, group, channel)
+ * - Thread support via m.thread relation
+ * - Message send via PUT (idempotent transaction IDs)
+ * - Health via GET /account/whoami
+ * - Room allowlist for security scoping
+ * - E2EE flag (placeholder; actual Olm/Megolm crypto deferred)
+ *
+ * API base: {homeserverUrl}/_matrix/client/v3
+ * Spec: https://spec.matrix.org/v1.9/client-server-api/
+ */
+import { z } from 'zod';
+import type { ChatProvider, MatrixAccountConfig, IncomingMessage } from '../types.js';
+/** Matrix event types for m.room.message */
+declare const MatrixMsgType: {
+    readonly TEXT: "m.text";
+    readonly NOTICE: "m.notice";
+    readonly EMOTE: "m.emote";
+    readonly IMAGE: "m.image";
+    readonly VIDEO: "m.video";
+    readonly AUDIO: "m.audio";
+    readonly FILE: "m.file";
+};
+/** Matrix room join rules */
+declare const MatrixRoomType: {
+    readonly DIRECT: "m.direct";
+    readonly GROUP: "group";
+};
+type MatrixMsgTypeValue = (typeof MatrixMsgType)[keyof typeof MatrixMsgType];
+interface MatrixEventContent {
+    msgtype?: MatrixMsgTypeValue;
+    body?: string;
+    format?: string;
+    formatted_body?: string;
+    url?: string;
+    info?: {
+        mimetype?: string;
+        size?: number;
+        w?: number;
+        h?: number;
+        duration?: number;
+    };
+    /** Relation metadata (m.thread, m.replace, m.annotation, m.in_reply_to) */
+    'm.relates_to'?: {
+        rel_type?: string;
+        event_id?: string;
+        is_falling_back?: boolean;
+        /** Annotation reaction key (emoji) for m.annotation rel_type */
+        key?: string;
+        'm.in_reply_to'?: {
+            event_id: string;
+        };
+    };
+    'm.new_content'?: {
+        msgtype?: MatrixMsgTypeValue;
+        body?: string;
+    };
+}
+interface MatrixEvent {
+    event_id: string;
+    type: string;
+    room_id: string;
+    sender: string;
+    origin_server_ts: number;
+    content: MatrixEventContent;
+    unsigned?: {
+        age?: number;
+        transaction_id?: string;
+        'm.relations'?: Record<string, unknown>;
+    };
+}
+interface MatrixRoomInfo {
+    room_id: string;
+    name?: string;
+    canonical_alias?: string;
+    is_direct?: boolean;
+}
+interface MatrixSyncRoomsJoined {
+    timeline?: {
+        events: MatrixEvent[];
+        limited?: boolean;
+        prev_batch?: string;
+    };
+    state?: {
+        events: MatrixEvent[];
+    };
+    account_data?: {
+        events: MatrixEvent[];
+    };
+}
+interface MatrixSyncResponse {
+    next_batch: string;
+    rooms?: {
+        join?: Record<string, MatrixSyncRoomsJoined>;
+        invite?: Record<string, unknown>;
+        leave?: Record<string, unknown>;
+    };
+}
+export declare const MatrixAccountConfigSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    isDefault: z.ZodOptional<z.ZodBoolean>;
+    provider: z.ZodLiteral<"matrix">;
+    homeserverUrl: z.ZodOptional<z.ZodString>;
+    accessToken: z.ZodOptional<z.ZodString>;
+    userId: z.ZodOptional<z.ZodString>;
+    deviceId: z.ZodOptional<z.ZodString>;
+    enableEncryption: z.ZodDefault<z.ZodBoolean>;
+    allowedRoomIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    provider: "matrix";
+    enabled: boolean;
+    enableEncryption: boolean;
+    name?: string | undefined;
+    userId?: string | undefined;
+    accessToken?: string | undefined;
+    isDefault?: boolean | undefined;
+    deviceId?: string | undefined;
+    homeserverUrl?: string | undefined;
+    allowedRoomIds?: string[] | undefined;
+}, {
+    id: string;
+    provider: "matrix";
+    name?: string | undefined;
+    userId?: string | undefined;
+    accessToken?: string | undefined;
+    isDefault?: boolean | undefined;
+    enabled?: boolean | undefined;
+    deviceId?: string | undefined;
+    homeserverUrl?: string | undefined;
+    enableEncryption?: boolean | undefined;
+    allowedRoomIds?: string[] | undefined;
+}>;
+type MatrixConfig = z.infer<typeof MatrixAccountConfigSchema>;
+/**
+ * Parse incoming events from a Matrix /sync response.
+ * Yields normalized IncomingMessage objects for all m.room.message events
+ * in joined rooms that pass the allowlist filter.
+ */
+export declare function parseSyncResponse(syncResponse: MatrixSyncResponse, directRoomIds?: Set<string>): IncomingMessage[];
+/**
+ * Fetch joined room info for a specific room.
+ * Returns room name and whether it's a direct message.
+ */
+export declare function getRoomInfo(roomId: string, config?: MatrixConfig | null): Promise<{
+    ok: boolean;
+    data?: MatrixRoomInfo;
+    error?: string;
+}>;
+export declare function setMatrixConfig(config: MatrixConfig): void;
+export declare function clearMatrixConfig(): void;
+export declare const matrixProvider: ChatProvider<MatrixAccountConfig>;
+export type { MatrixConfig, MatrixEvent, MatrixEventContent, MatrixSyncResponse };
+export { MatrixMsgType, MatrixRoomType };
+//# sourceMappingURL=index.d.ts.map