profclaw 0.0.1-beta.1

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

@@ -0,0 +1,166 @@
+/**
+ * iMessage Provider - iMessage via BlueBubbles REST API
+ * API base: {blueBubblesUrl}/api/v1
+ */
+import { z } from 'zod';
+import { logger } from '../../../utils/logger.js';
+// --- Schema ---
+export const IMessageAccountConfigSchema = z.object({
+    id: z.string(),
+    name: z.string().optional(),
+    enabled: z.boolean().default(true),
+    isDefault: z.boolean().optional(),
+    provider: z.literal('imessage'),
+    blueBubblesUrl: z.string().url().optional(),
+    blueBubblesPassword: z.string().optional(),
+    allowedAddresses: z.array(z.string()).optional(),
+});
+// --- State ---
+let currentConfig = null;
+// --- HTTP helper ---
+function buildBBUrl(path, config) {
+    const base = config.blueBubblesUrl?.replace(/\/$/, '') ?? '';
+    const password = encodeURIComponent(config.blueBubblesPassword ?? '');
+    const sep = path.includes('?') ? '&' : '?';
+    return `${base}/api/v1${path}${sep}password=${password}`;
+}
+async function callBBApi(path, method = 'GET', body, config) {
+    const cfg = config ?? currentConfig;
+    if (!cfg?.blueBubblesUrl)
+        return { ok: false, error: 'blueBubblesUrl not configured' };
+    if (!cfg.blueBubblesPassword)
+        return { ok: false, error: 'blueBubblesPassword not configured' };
+    try {
+        const res = await fetch(buildBBUrl(path, cfg), {
+            method,
+            headers: { 'Content-Type': 'application/json' },
+            body: body !== undefined ? JSON.stringify(body) : undefined,
+        });
+        const data = await res.json();
+        if (!res.ok)
+            return { ok: false, error: data.message ?? `HTTP ${res.status}` };
+        return { ok: true, data };
+    }
+    catch (error) {
+        logger.error('[iMessage] BlueBubbles API call failed:', error instanceof Error ? error : undefined);
+        return { ok: false, error: error instanceof Error ? error.message : 'Unknown error' };
+    }
+}
+// --- Adapters ---
+const authAdapter = {
+    getAuthUrl(_state, _scopes) {
+        throw new Error('iMessage via BlueBubbles uses password-based auth. Supply blueBubblesUrl and blueBubblesPassword.');
+    },
+    async exchangeCode(_code) {
+        throw new Error('BlueBubbles does not use OAuth code flow.');
+    },
+    verifyWebhook(_signature, _timestamp, _body) {
+        // BlueBubbles webhook auth is handled by the password query param at the route level.
+        return true;
+    },
+};
+const outboundAdapter = {
+    async send(message) {
+        if (!currentConfig?.blueBubblesUrl || !currentConfig.blueBubblesPassword) {
+            return { success: false, error: 'blueBubblesUrl and blueBubblesPassword are required' };
+        }
+        if (!message.to)
+            return { success: false, error: 'chatGuid (to) is required' };
+        const result = await callBBApi('/message/text', 'POST', {
+            chatGuid: message.to,
+            message: message.text ?? '',
+            method: 'apple-script',
+        });
+        return result.ok
+            ? { success: true, messageId: result.data?.data?.guid }
+            : { success: false, error: result.error ?? 'Failed to send iMessage' };
+    },
+};
+const inboundAdapter = {
+    parseMessage(payload) {
+        const event = payload;
+        if (!event || event.type !== 'new-message')
+            return null;
+        const msg = event.data;
+        if (!msg?.guid || msg.isFromMe)
+            return null;
+        const address = msg.handle?.address;
+        if (!address)
+            return null;
+        const allowed = currentConfig?.allowedAddresses;
+        if (allowed && allowed.length > 0 && !allowed.includes(address)) {
+            logger.debug(`[iMessage] parseMessage: address ${address} not in allowedAddresses, skipping`);
+            return null;
+        }
+        const firstChat = msg.chats?.[0];
+        return {
+            id: msg.guid,
+            provider: 'imessage',
+            accountId: currentConfig?.id ?? 'default',
+            senderId: address,
+            senderName: msg.handle?.displayName ?? address,
+            senderUsername: address,
+            chatType: firstChat?.isGroup ? 'group' : 'direct',
+            chatId: firstChat?.guid ?? address,
+            chatName: firstChat?.displayName,
+            threadId: undefined,
+            replyToId: undefined,
+            text: msg.text ?? '',
+            rawContent: event,
+            timestamp: msg.dateCreated ? new Date(msg.dateCreated) : new Date(),
+            attachments: undefined,
+        };
+    },
+    parseCommand(_payload) { return null; },
+    parseAction(_payload) { return null; },
+    buildCommandResponse(response) { return { message: response.text ?? '' }; },
+    buildActionResponse(response) { return { message: response.text ?? '' }; },
+};
+const statusAdapter = {
+    isConfigured(config) {
+        return !!(config.blueBubblesUrl && config.blueBubblesPassword);
+    },
+    async checkHealth(config) {
+        if (!config.blueBubblesUrl || !config.blueBubblesPassword) {
+            return { connected: false, error: 'blueBubblesUrl and blueBubblesPassword are required' };
+        }
+        const bbConfig = { ...config, provider: 'imessage', enabled: config.enabled ?? true };
+        const start = Date.now();
+        const result = await callBBApi('/server/info', 'GET', undefined, bbConfig);
+        const latencyMs = Date.now() - start;
+        if (result.ok && result.data) {
+            const info = result.data.data;
+            return {
+                connected: true, latencyMs,
+                details: { serverUrl: config.blueBubblesUrl, osVersion: info?.os_version, serverVersion: info?.server_version, privateApi: info?.private_api, helperConnected: info?.helper_connected },
+            };
+        }
+        return { connected: false, latencyMs, error: result.error ?? 'Failed to connect to BlueBubbles server' };
+    },
+};
+// --- Config management ---
+export function setIMessageConfig(config) { currentConfig = config; }
+export function clearIMessageConfig() { currentConfig = null; }
+// --- Provider export ---
+export const imessageProvider = {
+    meta: {
+        id: 'imessage', name: 'iMessage',
+        description: 'iMessage integration via BlueBubbles self-hosted server',
+        icon: 'iMessage icon',
+        docsUrl: 'https://bluebubbles.app/',
+        order: 21, color: '#34C759',
+    },
+    capabilities: {
+        chatTypes: ['direct', 'group'],
+        send: true, receive: true, slashCommands: false, interactiveComponents: false,
+        reactions: false, edit: false, delete: false, threads: false,
+        media: true, richBlocks: false, oauth: false, webhooks: true, realtime: false,
+    },
+    defaultConfig: { provider: 'imessage', enabled: true },
+    configSchema: IMessageAccountConfigSchema,
+    auth: authAdapter,
+    outbound: outboundAdapter,
+    inbound: inboundAdapter,
+    status: statusAdapter,
+};
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,76 @@
+/**
+ * Chat Providers Module
+ *
+ * Unified chat provider system supporting Slack, Discord, Telegram, WhatsApp, and more.
+ *
+ * Usage:
+ * ```ts
+ * import { getChatRegistry, slackProvider } from './chat/providers';
+ *
+ * // Register providers
+ * const registry = getChatRegistry();
+ * registry.register(slackProvider);
+ *
+ * // Send a message
+ * const provider = registry.get('slack');
+ * await provider?.outbound.send({ provider: 'slack', to: 'C123', text: 'Hello!' });
+ * ```
+ */
+export * from './types.js';
+export { getChatRegistry, resetChatRegistry, ChatProviderRegistry } from './registry.js';
+export { slackProvider, SlackAccountConfigSchema } from './slack/index.js';
+export { discordProvider, DiscordAccountConfigSchema } from './discord/index.js';
+export { telegramProvider, TelegramAccountConfigSchema } from './telegram/index.js';
+export { whatsappProvider, WhatsAppAccountConfigSchema } from './whatsapp/index.js';
+export { webchatProvider } from './webchat/index.js';
+export { matrixProvider, MatrixAccountConfigSchema } from './matrix/index.js';
+export { googlechatProvider, GoogleChatAccountConfigSchema } from './googlechat/index.js';
+export { msteamsProvider, MSTeamsAccountConfigSchema } from './msteams/index.js';
+export { signalProvider, SignalAccountConfigSchema } from './signal/index.js';
+export { ircProvider, IRCAccountConfigSchema } from './irc/index.js';
+export { lineProvider, LINEAccountConfigSchema } from './line/index.js';
+export { mattermostProvider, MattermostAccountConfigSchema } from './mattermost/index.js';
+export { dingtalkProvider, DingTalkAccountConfigSchema } from './dingtalk/index.js';
+export { wecomProvider, WeComAccountConfigSchema } from './wecom/index.js';
+export { feishuProvider, FeishuAccountConfigSchema } from './feishu/index.js';
+export { qqProvider, QQAccountConfigSchema } from './qq/index.js';
+export { nostrProvider, NostrAccountConfigSchema } from './nostr/index.js';
+export { twitchProvider, TwitchAccountConfigSchema } from './twitch/index.js';
+export { zaloProvider, ZaloAccountConfigSchema } from './zalo/index.js';
+export { nextcloudProvider, NextcloudAccountConfigSchema } from './nextcloud/index.js';
+export { imessageProvider, IMessageAccountConfigSchema } from './imessage/index.js';
+export { synologyProvider, SynologyAccountConfigSchema } from './synology/index.js';
+export { tlonProvider, TlonAccountConfigSchema } from './tlon/index.js';
+export { zaloPersonalProvider, ZaloPersonalAccountConfigSchema } from './zalo-personal/index.js';
+/**
+ * Initialize chat providers with default configuration
+ */
+export declare function initializeChatProviders(): void;
+import type { OutgoingMessage, SendResult, ChatProviderId } from './types.js';
+/**
+ * Send a message via the appropriate provider
+ */
+export declare function sendMessage(message: OutgoingMessage): Promise<SendResult>;
+/**
+ * Get provider status
+ */
+export declare function getProviderStatus(providerId: ChatProviderId): Promise<{
+    configured: boolean;
+    connected: boolean;
+    error: string;
+    latencyMs?: undefined;
+    details?: undefined;
+} | {
+    configured: boolean;
+    connected: boolean;
+    error?: undefined;
+    latencyMs?: undefined;
+    details?: undefined;
+} | {
+    configured: boolean;
+    connected: boolean;
+    latencyMs: number | undefined;
+    error: string | undefined;
+    details: Record<string, unknown> | undefined;
+}>;
+//# sourceMappingURL=index.d.ts.map

package/dist/chat/providers/index.js

@@ -0,0 +1,430 @@
+/**
+ * Chat Providers Module
+ *
+ * Unified chat provider system supporting Slack, Discord, Telegram, WhatsApp, and more.
+ *
+ * Usage:
+ * ```ts
+ * import { getChatRegistry, slackProvider } from './chat/providers';
+ *
+ * // Register providers
+ * const registry = getChatRegistry();
+ * registry.register(slackProvider);
+ *
+ * // Send a message
+ * const provider = registry.get('slack');
+ * await provider?.outbound.send({ provider: 'slack', to: 'C123', text: 'Hello!' });
+ * ```
+ */
+// Core types
+export * from './types.js';
+// Registry
+export { getChatRegistry, resetChatRegistry, ChatProviderRegistry } from './registry.js';
+// Providers
+export { slackProvider, SlackAccountConfigSchema } from './slack/index.js';
+export { discordProvider, DiscordAccountConfigSchema } from './discord/index.js';
+export { telegramProvider, TelegramAccountConfigSchema } from './telegram/index.js';
+export { whatsappProvider, WhatsAppAccountConfigSchema } from './whatsapp/index.js';
+export { webchatProvider } from './webchat/index.js';
+export { matrixProvider, MatrixAccountConfigSchema } from './matrix/index.js';
+export { googlechatProvider, GoogleChatAccountConfigSchema } from './googlechat/index.js';
+export { msteamsProvider, MSTeamsAccountConfigSchema } from './msteams/index.js';
+export { signalProvider, SignalAccountConfigSchema } from './signal/index.js';
+export { ircProvider, IRCAccountConfigSchema } from './irc/index.js';
+export { lineProvider, LINEAccountConfigSchema } from './line/index.js';
+export { mattermostProvider, MattermostAccountConfigSchema } from './mattermost/index.js';
+export { dingtalkProvider, DingTalkAccountConfigSchema } from './dingtalk/index.js';
+export { wecomProvider, WeComAccountConfigSchema } from './wecom/index.js';
+export { feishuProvider, FeishuAccountConfigSchema } from './feishu/index.js';
+export { qqProvider, QQAccountConfigSchema } from './qq/index.js';
+export { nostrProvider, NostrAccountConfigSchema } from './nostr/index.js';
+export { twitchProvider, TwitchAccountConfigSchema } from './twitch/index.js';
+export { zaloProvider, ZaloAccountConfigSchema } from './zalo/index.js';
+export { nextcloudProvider, NextcloudAccountConfigSchema } from './nextcloud/index.js';
+export { imessageProvider, IMessageAccountConfigSchema } from './imessage/index.js';
+export { synologyProvider, SynologyAccountConfigSchema } from './synology/index.js';
+export { tlonProvider, TlonAccountConfigSchema } from './tlon/index.js';
+export { zaloPersonalProvider, ZaloPersonalAccountConfigSchema } from './zalo-personal/index.js';
+// INITIALIZATION
+import { getChatRegistry } from './registry.js';
+import { slackProvider } from './slack/index.js';
+import { discordProvider } from './discord/index.js';
+import { telegramProvider } from './telegram/index.js';
+import { whatsappProvider } from './whatsapp/index.js';
+import { webchatProvider } from './webchat/index.js';
+import { matrixProvider } from './matrix/index.js';
+import { googlechatProvider } from './googlechat/index.js';
+import { msteamsProvider } from './msteams/index.js';
+import { signalProvider } from './signal/index.js';
+import { ircProvider } from './irc/index.js';
+import { lineProvider } from './line/index.js';
+import { mattermostProvider } from './mattermost/index.js';
+import { dingtalkProvider } from './dingtalk/index.js';
+import { wecomProvider } from './wecom/index.js';
+import { feishuProvider } from './feishu/index.js';
+import { qqProvider } from './qq/index.js';
+import { nostrProvider } from './nostr/index.js';
+import { twitchProvider } from './twitch/index.js';
+import { zaloProvider } from './zalo/index.js';
+import { nextcloudProvider } from './nextcloud/index.js';
+import { imessageProvider } from './imessage/index.js';
+import { synologyProvider } from './synology/index.js';
+import { tlonProvider } from './tlon/index.js';
+import { zaloPersonalProvider } from './zalo-personal/index.js';
+/**
+ * Initialize chat providers with default configuration
+ */
+export function initializeChatProviders() {
+    const registry = getChatRegistry();
+    // Register built-in providers
+    registry.register(slackProvider);
+    registry.register(discordProvider);
+    registry.register(telegramProvider);
+    registry.register(whatsappProvider);
+    registry.register(webchatProvider);
+    registry.register(matrixProvider);
+    registry.register(googlechatProvider);
+    registry.register(msteamsProvider);
+    registry.register(signalProvider);
+    registry.register(ircProvider);
+    registry.register(lineProvider);
+    registry.register(mattermostProvider);
+    registry.register(dingtalkProvider);
+    registry.register(wecomProvider);
+    registry.register(feishuProvider);
+    registry.register(qqProvider);
+    registry.register(nostrProvider);
+    registry.register(twitchProvider);
+    registry.register(zaloProvider);
+    registry.register(nextcloudProvider);
+    registry.register(imessageProvider);
+    registry.register(synologyProvider);
+    registry.register(tlonProvider);
+    registry.register(zaloPersonalProvider);
+    // WebChat is always available with default account
+    registry.registerAccount({
+        id: 'default',
+        provider: 'webchat',
+        name: 'WebChat',
+        enabled: true,
+        isDefault: true,
+        allowAnonymous: true,
+    });
+    // Register accounts from environment
+    if (process.env.SLACK_BOT_TOKEN || process.env.SLACK_SIGNING_SECRET) {
+        registry.registerAccount({
+            id: 'default',
+            provider: 'slack',
+            name: process.env.SLACK_TEAM_NAME || 'Default Workspace',
+            enabled: true,
+            isDefault: true,
+            mode: process.env.SLACK_MODE === 'socket' ? 'socket' : 'http',
+            botToken: process.env.SLACK_BOT_TOKEN,
+            appToken: process.env.SLACK_APP_TOKEN,
+            signingSecret: process.env.SLACK_SIGNING_SECRET,
+            webhookUrl: process.env.SLACK_WEBHOOK_URL,
+            teamId: process.env.SLACK_TEAM_ID,
+            teamName: process.env.SLACK_TEAM_NAME,
+        });
+    }
+    // Matrix account from environment
+    if (process.env.MATRIX_HOMESERVER_URL && process.env.MATRIX_ACCESS_TOKEN) {
+        registry.registerAccount({
+            id: 'default',
+            provider: 'matrix',
+            name: 'Matrix',
+            enabled: true,
+            isDefault: true,
+            homeserverUrl: process.env.MATRIX_HOMESERVER_URL,
+            accessToken: process.env.MATRIX_ACCESS_TOKEN,
+            userId: process.env.MATRIX_USER_ID,
+        });
+    }
+    // Google Chat account from environment
+    if (process.env.GOOGLE_CHAT_WEBHOOK_URL || process.env.GOOGLE_CHAT_SERVICE_ACCOUNT_KEY) {
+        registry.registerAccount({
+            id: 'default',
+            provider: 'googlechat',
+            name: 'Google Chat',
+            enabled: true,
+            isDefault: true,
+            webhookUrl: process.env.GOOGLE_CHAT_WEBHOOK_URL,
+            serviceAccountKey: process.env.GOOGLE_CHAT_SERVICE_ACCOUNT_KEY,
+            projectId: process.env.GOOGLE_CHAT_PROJECT_ID,
+        });
+    }
+    // MS Teams account from environment
+    if (process.env.MSTEAMS_APP_ID && process.env.MSTEAMS_APP_PASSWORD) {
+        registry.registerAccount({
+            id: 'default',
+            provider: 'msteams',
+            name: 'Microsoft Teams',
+            enabled: true,
+            isDefault: true,
+            appId: process.env.MSTEAMS_APP_ID,
+            appPassword: process.env.MSTEAMS_APP_PASSWORD,
+            tenantId: process.env.MSTEAMS_TENANT_ID,
+        });
+    }
+    // Signal account from environment
+    if (process.env.SIGNAL_PHONE_NUMBER) {
+        registry.registerAccount({
+            id: 'default',
+            provider: 'signal',
+            name: 'Signal',
+            enabled: true,
+            isDefault: true,
+            phoneNumber: process.env.SIGNAL_PHONE_NUMBER,
+            signaldSocketPath: process.env.SIGNALD_SOCKET_PATH,
+            allowedNumbers: process.env.SIGNAL_ALLOWED_NUMBERS
+                ? process.env.SIGNAL_ALLOWED_NUMBERS.split(',').map((n) => n.trim())
+                : undefined,
+        });
+    }
+    // IRC account from environment
+    if (process.env.IRC_SERVER && process.env.IRC_NICK) {
+        registry.registerAccount({
+            id: 'default',
+            provider: 'irc',
+            name: 'IRC',
+            enabled: true,
+            isDefault: true,
+            server: process.env.IRC_SERVER,
+            port: process.env.IRC_PORT ? parseInt(process.env.IRC_PORT, 10) : 6697,
+            nick: process.env.IRC_NICK,
+            password: process.env.IRC_PASSWORD,
+            channels: process.env.IRC_CHANNELS?.split(',').map((c) => c.trim()),
+            useTLS: process.env.IRC_USE_TLS !== 'false',
+        });
+    }
+    // LINE account from environment
+    if (process.env.LINE_CHANNEL_ACCESS_TOKEN && process.env.LINE_CHANNEL_SECRET) {
+        registry.registerAccount({
+            id: 'default',
+            provider: 'line',
+            name: 'LINE',
+            enabled: true,
+            isDefault: true,
+            channelAccessToken: process.env.LINE_CHANNEL_ACCESS_TOKEN,
+            channelSecret: process.env.LINE_CHANNEL_SECRET,
+        });
+    }
+    // Mattermost account from environment
+    if (process.env.MATTERMOST_SERVER_URL && process.env.MATTERMOST_BOT_TOKEN) {
+        registry.registerAccount({
+            id: 'default',
+            provider: 'mattermost',
+            name: 'Mattermost',
+            enabled: true,
+            isDefault: true,
+            serverUrl: process.env.MATTERMOST_SERVER_URL,
+            botToken: process.env.MATTERMOST_BOT_TOKEN,
+            teamId: process.env.MATTERMOST_TEAM_ID,
+        });
+    }
+    // DingTalk account from environment
+    if (process.env.DINGTALK_WEBHOOK_URL) {
+        registry.registerAccount({
+            id: 'default',
+            provider: 'dingtalk',
+            name: 'DingTalk',
+            enabled: true,
+            isDefault: true,
+            webhookUrl: process.env.DINGTALK_WEBHOOK_URL,
+            webhookSecret: process.env.DINGTALK_WEBHOOK_SECRET,
+            appKey: process.env.DINGTALK_APP_KEY,
+            appSecret: process.env.DINGTALK_APP_SECRET,
+        });
+    }
+    // WeCom account from environment
+    if (process.env.WECOM_WEBHOOK_URL || (process.env.WECOM_CORP_ID && process.env.WECOM_SECRET)) {
+        registry.registerAccount({
+            id: 'default',
+            provider: 'wecom',
+            name: 'WeCom',
+            enabled: true,
+            isDefault: true,
+            corpId: process.env.WECOM_CORP_ID,
+            agentId: process.env.WECOM_AGENT_ID,
+            secret: process.env.WECOM_SECRET,
+            token: process.env.WECOM_TOKEN,
+            encodingAESKey: process.env.WECOM_ENCODING_AES_KEY,
+            webhookUrl: process.env.WECOM_WEBHOOK_URL,
+        });
+    }
+    // Feishu/Lark account from environment
+    if (process.env.FEISHU_APP_ID && process.env.FEISHU_APP_SECRET) {
+        registry.registerAccount({
+            id: 'default',
+            provider: 'feishu',
+            name: 'Feishu',
+            enabled: true,
+            isDefault: true,
+            appId: process.env.FEISHU_APP_ID,
+            appSecret: process.env.FEISHU_APP_SECRET,
+            verificationToken: process.env.FEISHU_VERIFICATION_TOKEN,
+            encryptKey: process.env.FEISHU_ENCRYPT_KEY,
+        });
+    }
+    // QQ Bot account from environment
+    if (process.env.QQ_APP_ID && process.env.QQ_SECRET) {
+        registry.registerAccount({
+            id: 'default',
+            provider: 'qq',
+            name: 'QQ',
+            enabled: true,
+            isDefault: true,
+            appId: process.env.QQ_APP_ID,
+            token: process.env.QQ_TOKEN,
+            secret: process.env.QQ_SECRET,
+            sandboxMode: process.env.QQ_SANDBOX === 'true',
+        });
+    }
+    // Twitch account from environment
+    if (process.env.TWITCH_OAUTH_TOKEN && process.env.TWITCH_CLIENT_ID) {
+        registry.registerAccount({
+            id: 'default',
+            provider: 'twitch',
+            name: 'Twitch',
+            enabled: true,
+            isDefault: true,
+            oauthToken: process.env.TWITCH_OAUTH_TOKEN,
+            clientId: process.env.TWITCH_CLIENT_ID,
+            nick: process.env.TWITCH_NICK,
+            channels: process.env.TWITCH_CHANNELS?.split(',').map((c) => c.trim()),
+        });
+    }
+    // Zalo account from environment
+    if (process.env.ZALO_ACCESS_TOKEN) {
+        registry.registerAccount({
+            id: 'default',
+            provider: 'zalo',
+            name: 'Zalo',
+            enabled: true,
+            isDefault: true,
+            accessToken: process.env.ZALO_ACCESS_TOKEN,
+            refreshToken: process.env.ZALO_REFRESH_TOKEN,
+            oaId: process.env.ZALO_OA_ID,
+            secretKey: process.env.ZALO_SECRET_KEY,
+        });
+    }
+    // Nextcloud Talk account from environment
+    if (process.env.NEXTCLOUD_SERVER_URL && process.env.NEXTCLOUD_USERNAME) {
+        registry.registerAccount({
+            id: 'default',
+            provider: 'nextcloud',
+            name: 'Nextcloud Talk',
+            enabled: true,
+            isDefault: true,
+            serverUrl: process.env.NEXTCLOUD_SERVER_URL,
+            username: process.env.NEXTCLOUD_USERNAME,
+            password: process.env.NEXTCLOUD_PASSWORD,
+            token: process.env.NEXTCLOUD_TALK_TOKEN,
+        });
+    }
+    // iMessage (BlueBubbles) account from environment
+    if (process.env.BLUEBUBBLES_URL && process.env.BLUEBUBBLES_PASSWORD) {
+        registry.registerAccount({
+            id: 'default',
+            provider: 'imessage',
+            name: 'iMessage',
+            enabled: true,
+            isDefault: true,
+            blueBubblesUrl: process.env.BLUEBUBBLES_URL,
+            blueBubblesPassword: process.env.BLUEBUBBLES_PASSWORD,
+            allowedAddresses: process.env.IMESSAGE_ALLOWED_ADDRESSES?.split(',').map((a) => a.trim()),
+        });
+    }
+    // Synology Chat account from environment
+    if (process.env.SYNOLOGY_INCOMING_WEBHOOK_URL) {
+        registry.registerAccount({
+            id: 'default',
+            provider: 'synology',
+            name: 'Synology Chat',
+            enabled: true,
+            isDefault: true,
+            serverUrl: process.env.SYNOLOGY_SERVER_URL,
+            incomingWebhookUrl: process.env.SYNOLOGY_INCOMING_WEBHOOK_URL,
+            outgoingWebhookToken: process.env.SYNOLOGY_OUTGOING_WEBHOOK_TOKEN,
+        });
+    }
+    // Nostr account from environment
+    if (process.env.NOSTR_PRIVATE_KEY) {
+        registry.registerAccount({
+            id: 'default',
+            provider: 'nostr',
+            name: 'Nostr',
+            enabled: true,
+            isDefault: true,
+            privateKey: process.env.NOSTR_PRIVATE_KEY,
+            relayUrls: process.env.NOSTR_RELAY_URLS?.split(',').map((u) => u.trim()),
+            allowedPubkeys: process.env.NOSTR_ALLOWED_PUBKEYS?.split(',').map((p) => p.trim()),
+        });
+    }
+    // Tlon/Urbit account from environment
+    if (process.env['TLON_SHIP_URL'] && process.env['TLON_SHIP_CODE']) {
+        registry.registerAccount({
+            id: 'default',
+            provider: 'tlon',
+            name: 'Tlon',
+            enabled: true,
+            isDefault: true,
+            shipUrl: process.env['TLON_SHIP_URL'],
+            shipCode: process.env['TLON_SHIP_CODE'],
+            shipName: process.env['TLON_SHIP_NAME'],
+            channelPath: process.env['TLON_CHANNEL_PATH'],
+        });
+    }
+    // Zalo Personal account from environment
+    if (process.env['ZALO_PERSONAL_ACCESS_TOKEN']) {
+        registry.registerAccount({
+            id: 'default',
+            provider: 'zalo-personal',
+            name: 'Zalo Personal',
+            enabled: true,
+            isDefault: true,
+            accessToken: process.env['ZALO_PERSONAL_ACCESS_TOKEN'],
+            secretKey: process.env['ZALO_PERSONAL_SECRET_KEY'],
+            userId: process.env['ZALO_PERSONAL_USER_ID'],
+        });
+    }
+    // Future: Load additional providers from database or config file
+}
+/**
+ * Send a message via the appropriate provider
+ */
+export async function sendMessage(message) {
+    const registry = getChatRegistry();
+    const provider = registry.get(message.provider);
+    if (!provider) {
+        return { success: false, error: `Provider ${message.provider} not found` };
+    }
+    return provider.outbound.send(message);
+}
+/**
+ * Get provider status
+ */
+export async function getProviderStatus(providerId) {
+    const registry = getChatRegistry();
+    const provider = registry.get(providerId);
+    if (!provider) {
+        return { configured: false, connected: false, error: 'Provider not found' };
+    }
+    const account = registry.getDefaultAccount(providerId);
+    if (!account) {
+        return { configured: false, connected: false, error: 'No account configured' };
+    }
+    const configured = provider.status.isConfigured(account);
+    if (!configured) {
+        return { configured: false, connected: false };
+    }
+    const health = await provider.status.checkHealth(account);
+    return {
+        configured: true,
+        connected: health.connected,
+        latencyMs: health.latencyMs,
+        error: health.error,
+        details: health.details,
+    };
+}
+//# sourceMappingURL=index.js.map