profclaw 0.0.1-beta.1

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

@@ -0,0 +1,52 @@
+/**
+ * Nextcloud Talk Provider - Nextcloud Talk team messaging
+ * API base: {serverUrl}/ocs/v2.php/apps/spreed/api/v4
+ */
+import { z } from 'zod';
+import type { ChatProvider, NextcloudAccountConfig } from '../types.js';
+export interface NextcloudChatMessage {
+    id: number;
+    token: string;
+    actorId: string;
+    actorDisplayName: string;
+    message: string;
+    messageType?: string;
+    timestamp: number;
+}
+export declare const NextcloudAccountConfigSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    isDefault: z.ZodOptional<z.ZodBoolean>;
+    provider: z.ZodLiteral<"nextcloud">;
+    serverUrl: z.ZodOptional<z.ZodString>;
+    username: z.ZodOptional<z.ZodString>;
+    password: z.ZodOptional<z.ZodString>;
+    token: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    provider: "nextcloud";
+    enabled: boolean;
+    name?: string | undefined;
+    isDefault?: boolean | undefined;
+    token?: string | undefined;
+    password?: string | undefined;
+    username?: string | undefined;
+    serverUrl?: string | undefined;
+}, {
+    id: string;
+    provider: "nextcloud";
+    name?: string | undefined;
+    isDefault?: boolean | undefined;
+    token?: string | undefined;
+    enabled?: boolean | undefined;
+    password?: string | undefined;
+    username?: string | undefined;
+    serverUrl?: string | undefined;
+}>;
+type NextcloudConfig = z.infer<typeof NextcloudAccountConfigSchema>;
+export declare function setNextcloudConfig(config: NextcloudConfig): void;
+export declare function clearNextcloudConfig(): void;
+export declare const nextcloudProvider: ChatProvider<NextcloudAccountConfig>;
+export type { NextcloudConfig };
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,156 @@
+/**
+ * Nextcloud Talk Provider - Nextcloud Talk team messaging
+ * API base: {serverUrl}/ocs/v2.php/apps/spreed/api/v4
+ */
+import { z } from 'zod';
+import { logger } from '../../../utils/logger.js';
+// --- Schema ---
+export const NextcloudAccountConfigSchema = z.object({
+    id: z.string(),
+    name: z.string().optional(),
+    enabled: z.boolean().default(true),
+    isDefault: z.boolean().optional(),
+    provider: z.literal('nextcloud'),
+    serverUrl: z.string().url().optional(),
+    username: z.string().optional(),
+    password: z.string().optional(),
+    token: z.string().optional(),
+});
+// --- State ---
+let currentConfig = null;
+// --- HTTP helper ---
+async function callNcApi(path, method = 'GET', body, config) {
+    const cfg = config ?? currentConfig;
+    if (!cfg?.serverUrl)
+        return { ok: false, error: 'serverUrl not configured' };
+    if (!cfg.username || !cfg.password)
+        return { ok: false, error: 'username and password are required' };
+    const base = cfg.serverUrl.replace(/\/$/, '');
+    const creds = Buffer.from(`${cfg.username}:${cfg.password}`).toString('base64');
+    const url = `${base}/ocs/v2.php/apps/spreed/api/v4${path}?format=json`;
+    try {
+        const res = await fetch(url, {
+            method,
+            headers: {
+                'Authorization': `Basic ${creds}`,
+                'OCS-APIRequest': 'true',
+                'Content-Type': 'application/json',
+                'Accept': 'application/json',
+            },
+            body: body !== undefined ? JSON.stringify(body) : undefined,
+        });
+        const data = await res.json();
+        if (!res.ok) {
+            const ocsData = data;
+            return { ok: false, error: ocsData?.ocs?.meta?.message ?? `HTTP ${res.status}` };
+        }
+        return { ok: true, data };
+    }
+    catch (error) {
+        logger.error('[Nextcloud] 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('Nextcloud Talk uses Basic auth. Supply serverUrl, username, and password.');
+    },
+    async exchangeCode(_code) {
+        throw new Error('Nextcloud Talk does not use OAuth code flow. Use an app password from Nextcloud Security settings.');
+    },
+    verifyWebhook(_signature, _timestamp, _body) {
+        // Nextcloud Talk webhook verification relies on network-level access control.
+        return true;
+    },
+};
+const outboundAdapter = {
+    async send(message) {
+        if (!currentConfig?.serverUrl)
+            return { success: false, error: 'serverUrl not configured' };
+        const roomToken = message.to ?? currentConfig.token;
+        if (!roomToken)
+            return { success: false, error: 'Room token (to or config.token) is required' };
+        const result = await callNcApi(`/chat/${roomToken}`, 'POST', { message: message.text ?? '' });
+        return result.ok
+            ? { success: true, messageId: result.data?.ocs?.data?.id !== undefined ? String(result.data.ocs.data.id) : undefined }
+            : { success: false, error: result.error ?? 'Failed to send message' };
+    },
+};
+const inboundAdapter = {
+    parseMessage(payload) {
+        const msg = payload;
+        if (!msg || !msg.token || !msg.actorId || !msg.message)
+            return null;
+        if (msg.messageType && msg.messageType !== 'comment')
+            return null;
+        return {
+            id: String(msg.id),
+            provider: 'nextcloud',
+            accountId: currentConfig?.id ?? 'default',
+            senderId: msg.actorId,
+            senderName: msg.actorDisplayName ?? msg.actorId,
+            senderUsername: msg.actorId,
+            chatType: 'group',
+            chatId: msg.token,
+            chatName: undefined,
+            threadId: undefined,
+            replyToId: undefined,
+            text: msg.message,
+            rawContent: msg,
+            timestamp: msg.timestamp ? new Date(msg.timestamp * 1000) : 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.serverUrl && config.username && config.password);
+    },
+    async checkHealth(config) {
+        if (!config.serverUrl || !config.username || !config.password) {
+            return { connected: false, error: 'serverUrl, username, and password are required' };
+        }
+        const ncConfig = { ...config, provider: 'nextcloud', enabled: config.enabled ?? true };
+        const start = Date.now();
+        const result = await callNcApi('/room', 'GET', undefined, ncConfig);
+        const latencyMs = Date.now() - start;
+        if (result.ok) {
+            return {
+                connected: true, latencyMs,
+                details: { serverUrl: config.serverUrl, username: config.username, roomCount: result.data?.ocs?.data?.length ?? 0 },
+            };
+        }
+        return { connected: false, latencyMs, error: result.error ?? 'Failed to connect to Nextcloud Talk API' };
+    },
+};
+// --- Config management ---
+export function setNextcloudConfig(config) { currentConfig = config; }
+export function clearNextcloudConfig() { currentConfig = null; }
+// --- Provider export ---
+export const nextcloudProvider = {
+    meta: {
+        id: 'nextcloud', name: 'Nextcloud Talk',
+        description: 'Nextcloud Talk self-hosted team messaging and video calls',
+        icon: 'Nextcloud icon',
+        docsUrl: 'https://nextcloud-talk.readthedocs.io/en/latest/',
+        order: 20, color: '#0082C9',
+    },
+    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: 'nextcloud', enabled: true },
+    configSchema: NextcloudAccountConfigSchema,
+    auth: authAdapter,
+    outbound: outboundAdapter,
+    inbound: inboundAdapter,
+    status: statusAdapter,
+};
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,60 @@
+/**
+ * Nostr Provider - kind 1 (public note) and kind 4 (encrypted DM / NIP-04).
+ * Outbound: POST signed events via bare ["EVENT", event] HTTP POST to relay.
+ * Inbound: parse wire messages ["EVENT", subscription_id, { ...event }].
+ * IMPORTANT: signing and NIP-04 encryption are TODO stubs.
+ * Install @noble/secp256k1 + @noble/hashes and replace the stubs below.
+ * Docs: https://github.com/nostr-protocol/nostr
+ */
+import { z } from 'zod';
+import type { ChatProvider, NostrAccountConfig } from '../types.js';
+declare const NostrKind: {
+    readonly PUBLIC_NOTE: 1;
+    readonly ENCRYPTED_DM: 4;
+};
+type NostrKindValue = (typeof NostrKind)[keyof typeof NostrKind];
+interface NostrEvent {
+    id: string;
+    pubkey: string;
+    created_at: number;
+    kind: NostrKindValue;
+    tags: string[][];
+    content: string;
+    sig: string;
+}
+type NostrWireMessage = ['EVENT', string, NostrEvent] | [string, ...unknown[]];
+export declare const NostrAccountConfigSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    isDefault: z.ZodOptional<z.ZodBoolean>;
+    provider: z.ZodLiteral<"nostr">;
+    privateKey: z.ZodOptional<z.ZodString>;
+    relayUrls: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    allowedPubkeys: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    provider: "nostr";
+    enabled: boolean;
+    name?: string | undefined;
+    isDefault?: boolean | undefined;
+    privateKey?: string | undefined;
+    relayUrls?: string[] | undefined;
+    allowedPubkeys?: string[] | undefined;
+}, {
+    id: string;
+    provider: "nostr";
+    name?: string | undefined;
+    isDefault?: boolean | undefined;
+    enabled?: boolean | undefined;
+    privateKey?: string | undefined;
+    relayUrls?: string[] | undefined;
+    allowedPubkeys?: string[] | undefined;
+}>;
+type NostrConfig = z.infer<typeof NostrAccountConfigSchema>;
+export declare function setNostrConfig(config: NostrConfig): void;
+export declare function clearNostrConfig(): void;
+export declare const nostrProvider: ChatProvider<NostrAccountConfig>;
+export type { NostrConfig, NostrEvent, NostrWireMessage };
+export { NostrKind };
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,200 @@
+/**
+ * Nostr Provider - kind 1 (public note) and kind 4 (encrypted DM / NIP-04).
+ * Outbound: POST signed events via bare ["EVENT", event] HTTP POST to relay.
+ * Inbound: parse wire messages ["EVENT", subscription_id, { ...event }].
+ * IMPORTANT: signing and NIP-04 encryption are TODO stubs.
+ * Install @noble/secp256k1 + @noble/hashes and replace the stubs below.
+ * Docs: https://github.com/nostr-protocol/nostr
+ */
+import { z } from 'zod';
+import { logger } from '../../../utils/logger.js';
+// --- Types ---
+const NostrKind = { PUBLIC_NOTE: 1, ENCRYPTED_DM: 4 };
+// --- Config ---
+export const NostrAccountConfigSchema = z.object({
+    id: z.string(),
+    name: z.string().optional(),
+    enabled: z.boolean().default(true),
+    isDefault: z.boolean().optional(),
+    provider: z.literal('nostr'),
+    privateKey: z.string().optional(),
+    relayUrls: z.array(z.string().url()).optional(),
+    allowedPubkeys: z.array(z.string()).optional(),
+});
+let currentConfig = null;
+// --- Meta + Capabilities ---
+const meta = {
+    id: 'nostr', name: 'Nostr', order: 17, color: '#8B5CF6',
+    description: 'Decentralized protocol using cryptographic keys and relays',
+    icon: 'Nostr icon',
+    docsUrl: 'https://github.com/nostr-protocol/nostr',
+};
+const capabilities = {
+    chatTypes: ['direct', 'group'],
+    send: true, receive: true, webhooks: true,
+    slashCommands: false, interactiveComponents: false,
+    reactions: false, edit: false, delete: false,
+    threads: false, media: false, richBlocks: false,
+    oauth: false, realtime: false,
+};
+// --- Crypto stubs (TODO: implement with @noble/secp256k1 + @noble/hashes) ---
+/** TODO: secp256k1.getPublicKey(privkey, true).slice(2) */
+function derivePubkey(_privateKey) {
+    logger.warn('[Nostr] derivePubkey: crypto stub - install @noble/secp256k1');
+    return 'stub-pubkey';
+}
+// TODO: id = sha256(JSON.stringify([0, pubkey, created_at, kind, tags, content])), sig = schnorr sign
+function signEvent(partial, _privateKey) {
+    logger.warn('[Nostr] signEvent: crypto stub - install @noble/secp256k1');
+    return { ...partial, id: 'stub-id', sig: 'stub-sig' };
+}
+// TODO: NIP-04 ECDH(senderPrivkey, recipientPubkey) -> AES-256-CBC -> base64(ct)+'?iv='+base64(iv)
+function encryptNip04(content, _senderPrivkey, _recipientPubkey) {
+    logger.warn('[Nostr] encryptNip04: NIP-04 crypto stub - implement before using DMs');
+    return content;
+}
+// --- Auth ---
+const authAdapter = {
+    getAuthUrl(_state, _scopes) {
+        throw new Error('Nostr does not use OAuth. Supply a private key in config.');
+    },
+    async exchangeCode(_code) {
+        throw new Error('Nostr does not use OAuth authorization codes.');
+    },
+    verifyWebhook(_sig, _ts, _body) {
+        // Relay trust model - each event carries its own cryptographic signature.
+        return true;
+    },
+};
+// --- Outbound ---
+const outboundAdapter = {
+    async send(message) {
+        if (!currentConfig?.privateKey)
+            return { success: false, error: 'Nostr private key not configured' };
+        if (!message.to)
+            return { success: false, error: 'Recipient pubkey (to) is required' };
+        const relayUrl = currentConfig.relayUrls?.[0];
+        if (!relayUrl)
+            return { success: false, error: 'No relay URLs configured' };
+        const isDm = message.chatType === 'direct';
+        const event = signEvent({
+            pubkey: derivePubkey(currentConfig.privateKey),
+            created_at: Math.floor(Date.now() / 1000),
+            kind: isDm ? NostrKind.ENCRYPTED_DM : NostrKind.PUBLIC_NOTE,
+            tags: isDm ? [['p', message.to]] : [],
+            content: isDm
+                ? encryptNip04(message.text ?? '', currentConfig.privateKey, message.to)
+                : (message.text ?? ''),
+        }, currentConfig.privateKey);
+        try {
+            const res = await fetch(relayUrl, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', 'Accept': 'application/json' },
+                body: JSON.stringify(['EVENT', event]),
+            });
+            return res.ok
+                ? { success: true, messageId: event.id }
+                : { success: false, error: `HTTP ${res.status}` };
+        }
+        catch (error) {
+            return { success: false, error: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+};
+// --- Inbound ---
+const inboundAdapter = {
+    parseMessage(payload) {
+        if (!Array.isArray(payload) || payload[0] !== 'EVENT' || payload.length < 3)
+            return null;
+        const event = payload[2];
+        if (!event || typeof event !== 'object')
+            return null;
+        const { id, pubkey, kind, content, tags, created_at } = event;
+        if (kind !== NostrKind.PUBLIC_NOTE && kind !== NostrKind.ENCRYPTED_DM) {
+            logger.debug(`[Nostr] parseMessage: unsupported kind ${kind}, skipping`);
+            return null;
+        }
+        const allowed = currentConfig?.allowedPubkeys;
+        if (allowed && allowed.length > 0 && !allowed.includes(pubkey)) {
+            logger.debug(`[Nostr] parseMessage: pubkey ${pubkey} not in allowedPubkeys`);
+            return null;
+        }
+        const recipientPubkey = tags.find((t) => t[0] === 'p')?.[1];
+        const isDm = kind === NostrKind.ENCRYPTED_DM;
+        // TODO: decrypt content for kind 4 (NIP-04) once crypto stubs are implemented
+        return {
+            id,
+            provider: 'nostr',
+            accountId: currentConfig?.id ?? 'default',
+            senderId: pubkey,
+            senderName: pubkey,
+            senderUsername: pubkey,
+            chatType: isDm ? 'direct' : 'group',
+            chatId: isDm ? (recipientPubkey ?? pubkey) : 'global',
+            chatName: undefined,
+            threadId: undefined,
+            replyToId: undefined,
+            text: content,
+            rawContent: event,
+            timestamp: new Date(created_at * 1000),
+            attachments: undefined,
+        };
+    },
+    parseCommand(_payload) { return null; },
+    parseAction(_payload) { return null; },
+    buildCommandResponse(r) { return { type: 'text', content: r.text ?? '' }; },
+    buildActionResponse(r) { return { type: 'text', content: r.text ?? '' }; },
+};
+// --- Status ---
+const statusAdapter = {
+    isConfigured(config) {
+        return !!(config.privateKey && config.relayUrls && config.relayUrls.length > 0);
+    },
+    async checkHealth(config) {
+        const relayUrl = config.relayUrls?.[0];
+        if (!relayUrl)
+            return { connected: false, error: 'No relay URLs configured' };
+        const start = Date.now();
+        try {
+            const res = await fetch(relayUrl, {
+                method: 'HEAD',
+                headers: { 'Accept': 'application/nostr+json' },
+                signal: AbortSignal.timeout(5000),
+            });
+            return {
+                connected: true,
+                latencyMs: Date.now() - start,
+                details: {
+                    relayUrl,
+                    relayCount: config.relayUrls?.length ?? 1,
+                    httpStatus: res.status,
+                    privateKeyConfigured: !!config.privateKey,
+                    allowedPubkeys: config.allowedPubkeys?.length ?? 0,
+                },
+            };
+        }
+        catch (error) {
+            return {
+                connected: false,
+                latencyMs: Date.now() - start,
+                error: error instanceof Error ? error.message : 'Failed to reach relay',
+            };
+        }
+    },
+};
+// --- Config helpers ---
+export function setNostrConfig(config) { currentConfig = config; }
+export function clearNostrConfig() { currentConfig = null; }
+// --- Provider export ---
+export const nostrProvider = {
+    meta,
+    capabilities,
+    defaultConfig: { provider: 'nostr', enabled: true },
+    configSchema: NostrAccountConfigSchema,
+    auth: authAdapter,
+    outbound: outboundAdapter,
+    inbound: inboundAdapter,
+    status: statusAdapter,
+};
+export { NostrKind };
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+import type { ChatProvider, QQAccountConfig } from '../types.js';
+interface QQAuthor {
+    id: string;
+    username: string;
+}
+interface QQEventData {
+    id: string;
+    content: string;
+    author: QQAuthor;
+    channel_id?: string;
+    guild_id?: string;
+    group_id?: string;
+    group_openid?: string;
+}
+interface QQWebhookPayload {
+    op: number;
+    t?: string;
+    d?: QQEventData;
+}
+export declare const QQAccountConfigSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    isDefault: z.ZodOptional<z.ZodBoolean>;
+    provider: z.ZodLiteral<"qq">;
+    appId: z.ZodOptional<z.ZodString>;
+    token: z.ZodOptional<z.ZodString>;
+    secret: z.ZodOptional<z.ZodString>;
+    sandboxMode: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    provider: "qq";
+    enabled: boolean;
+    name?: string | undefined;
+    secret?: string | undefined;
+    isDefault?: boolean | undefined;
+    token?: string | undefined;
+    appId?: string | undefined;
+    sandboxMode?: boolean | undefined;
+}, {
+    id: string;
+    provider: "qq";
+    name?: string | undefined;
+    secret?: string | undefined;
+    isDefault?: boolean | undefined;
+    token?: string | undefined;
+    enabled?: boolean | undefined;
+    appId?: string | undefined;
+    sandboxMode?: boolean | undefined;
+}>;
+type QQConfig = z.infer<typeof QQAccountConfigSchema>;
+export declare function setQQConfig(config: QQConfig): void;
+export declare function clearQQConfig(): void;
+export declare const qqProvider: ChatProvider<QQAccountConfig>;
+export type { QQConfig, QQWebhookPayload, QQEventData };
+//# sourceMappingURL=index.d.ts.map