@phuetz/code-buddy 1.0.0 → 1.2.0

package/dist/channels/nextcloud-talk/index.js

@@ -1,11 +1,15 @@
 /**
  * Nextcloud Talk Channel Adapter
  *
- * Connects to Nextcloud Talk for messaging and room management.
- * Provides a lightweight in-process adapter for lifecycle and room flows.
+ * Connects to Nextcloud Talk (Spreed) for messaging via the real Spreed chat
+ * REST API using an HTTP long-poll receive loop (`lookIntoFuture=1`), with
+ * auto-reconnect through the shared ReconnectionManager (same idiom as
+ * imessage/irc/discord/slack).
  */
+import { EventEmitter } from 'events';
 import { logger } from '../../utils/logger.js';
-import { BaseChannel } from '../core.js';
+import { BaseChannel, } from '../core.js';
+import { ReconnectionManager } from '../reconnection-manager.js';
 export class NextcloudTalkAdapter {
     config;
     running = false;
@@ -64,8 +68,325 @@ export class NextcloudTalkAdapter {
         return { ...this.config };
     }
 }
+const SPREED_CHAT_PATH = '/ocs/v2.php/apps/spreed/api/v1/chat';
+/**
+ * Real Nextcloud Talk (Spreed) client. Holds one outstanding long-poll request
+ * against `chat/<roomToken>?lookIntoFuture=1` at a time; the server returns 200
+ * with new messages or 304 on timeout. Drops are recovered via the shared
+ * ReconnectionManager. This is a genuinely persistent connection model — the
+ * same shape as imessage/irc.
+ */
+export class NextcloudTalkClient extends EventEmitter {
+    baseUrl;
+    username;
+    password;
+    bearer;
+    roomToken;
+    pollTimeoutSecs;
+    running = false;
+    /** True while an intentional disconnect is in progress — suppresses reconnect. */
+    closing = false;
+    reconnecting = false;
+    lastKnownMessageId = 0;
+    /** AbortController for the in-flight long-poll request. */
+    pollAbort = null;
+    reconnectionManager;
+    constructor(config) {
+        super();
+        this.baseUrl = config.url.replace(/\/+$/, '');
+        this.username = config.username;
+        this.password = config.appPassword ?? config.password;
+        this.bearer = config.bearer ?? config.token;
+        this.roomToken = config.roomToken ?? '';
+        this.pollTimeoutSecs = config.pollTimeoutSecs ?? 30;
+        this.reconnectionManager = new ReconnectionManager('nextcloud-talk', {
+            maxRetries: config.maxRetries ?? 10,
+            initialDelayMs: config.retryDelayMs ?? 2000,
+            maxDelayMs: 60000,
+        });
+    }
+    isRunning() {
+        return this.running;
+    }
+    getRoomToken() {
+        return this.roomToken;
+    }
+    // --------------------------------------------------------------------------
+    // Lifecycle
+    // --------------------------------------------------------------------------
+    /**
+     * Begin the long-poll receive loop. Returns immediately — `connect()` does
+     * NOT block on the first poll (a long-poll can hold open up to
+     * `pollTimeoutSecs`). The first successful poll (200 or 304) emits
+     * 'connected'.
+     */
+    start() {
+        if (this.running) {
+            throw new Error('NextcloudTalkClient is already running');
+        }
+        this.running = true;
+        this.closing = false;
+        // Fresh session — clear any inherited backoff state.
+        this.reconnectionManager.onConnected();
+        logger.debug('NextcloudTalkClient: starting long-poll loop', {
+            url: this.baseUrl,
+            room: this.roomToken,
+        });
+        void this.runPollLoop();
+    }
+    /**
+     * Stop the loop, abort the in-flight request, and cancel any pending
+     * reconnect. Idempotent.
+     */
+    stop() {
+        if (!this.running && !this.closing) {
+            return;
+        }
+        this.closing = true;
+        this.running = false;
+        this.reconnecting = false;
+        this.reconnectionManager.cancel();
+        if (this.pollAbort) {
+            this.pollAbort.abort();
+            this.pollAbort = null;
+        }
+        logger.debug('NextcloudTalkClient: stopped');
+    }
+    // --------------------------------------------------------------------------
+    // Receive (long-poll)
+    // --------------------------------------------------------------------------
+    async runPollLoop() {
+        while (this.running && !this.closing) {
+            try {
+                await this.pollOnce();
+                // A successful poll (messages or 304 timeout) means the link is
+                // healthy — reset shared backoff so a future drop starts at delay 0.
+                this.reconnectionManager.onConnected();
+                this.reconnecting = false;
+                this.onConnectedOnce();
+            }
+            catch (err) {
+                // Intentional teardown — exit silently, never reconnect.
+                if (this.closing || !this.running || this.isAbortError(err)) {
+                    return;
+                }
+                const error = err instanceof Error ? err : new Error(String(err));
+                logger.warn('NextcloudTalkClient: poll error, scheduling reconnect', {
+                    error: error.message,
+                });
+                // Surface the error, but only when a listener exists — a bare
+                // EventEmitter 'error' with no listener throws and would abort the
+                // reconnect we're about to schedule. Scheduling comes first regardless.
+                this.scheduleReconnect();
+                if (this.listenerCount('error') > 0) {
+                    this.emit('error', error);
+                }
+                // Hand control to the ReconnectionManager — it owns the retry cadence.
+                return;
+            }
+        }
+    }
+    /**
+     * Issue one long-poll request. Resolves on 200 (with messages emitted) or 304
+     * (timeout, no messages). Throws on network failure / non-2xx-non-304 status
+     * (a real drop → triggers reconnect).
+     */
+    async pollOnce() {
+        const params = new URLSearchParams({
+            lookIntoFuture: '1',
+            timeout: String(this.pollTimeoutSecs),
+            lastKnownMessageId: String(this.lastKnownMessageId),
+            setReadMarker: '0',
+        });
+        const url = `${this.baseUrl}${SPREED_CHAT_PATH}/${encodeURIComponent(this.roomToken)}?${params.toString()}`;
+        // Abort the request slightly after the server-side hold timeout so a wedged
+        // connection can't pin the loop forever.
+        const abort = new AbortController();
+        this.pollAbort = abort;
+        const watchdog = setTimeout(() => abort.abort(), (this.pollTimeoutSecs + 10) * 1000);
+        watchdog.unref?.();
+        let response;
+        try {
+            response = await fetch(url, {
+                method: 'GET',
+                headers: this.buildHeaders(),
+                signal: abort.signal,
+            });
+        }
+        finally {
+            clearTimeout(watchdog);
+            if (this.pollAbort === abort) {
+                this.pollAbort = null;
+            }
+        }
+        // 304 = long-poll timed out with no new messages — a SUCCESSFUL empty poll,
+        // not an error and not a reconnect trigger.
+        if (response.status === 304) {
+            return;
+        }
+        if (!response.ok) {
+            const body = await response.text().catch(() => '');
+            throw new Error(`Nextcloud Talk poll failed: ${response.status} ${response.statusText} - ${body}`);
+        }
+        const lastGiven = response.headers.get('X-Chat-Last-Given');
+        const envelope = (await response.json().catch(() => ({})));
+        const messages = envelope.ocs?.data ?? [];
+        let maxId = this.lastKnownMessageId;
+        for (const raw of messages) {
+            if (typeof raw.id === 'number' && raw.id > maxId) {
+                maxId = raw.id;
+            }
+            // Skip system messages (joins/leaves/etc.) — they have no user content.
+            if (raw.systemMessage) {
+                continue;
+            }
+            this.emit('message', this.toInbound(raw));
+        }
+        // Advance the cursor from the server-provided header when present, else from
+        // the max message id we saw.
+        const givenId = lastGiven ? Number.parseInt(lastGiven, 10) : NaN;
+        if (Number.isFinite(givenId) && givenId > this.lastKnownMessageId) {
+            this.lastKnownMessageId = givenId;
+        }
+        else if (maxId > this.lastKnownMessageId) {
+            this.lastKnownMessageId = maxId;
+        }
+    }
+    toInbound(raw) {
+        const sender = raw.actorId ?? 'unknown';
+        const content = raw.message ?? '';
+        const isCommand = content.startsWith('/');
+        const contentType = isCommand ? 'command' : 'text';
+        const message = {
+            id: String(raw.id),
+            channel: {
+                id: raw.token ?? this.roomToken,
+                type: 'nextcloud-talk',
+                name: raw.token ?? this.roomToken,
+                isGroup: true,
+            },
+            sender: {
+                id: sender,
+                username: sender,
+                displayName: raw.actorDisplayName ?? sender,
+                isBot: raw.actorType === 'bots',
+            },
+            content,
+            contentType,
+            timestamp: raw.timestamp ? new Date(raw.timestamp * 1000) : new Date(),
+            raw,
+        };
+        if (isCommand) {
+            const parts = content.slice(1).split(/\s+/);
+            message.isCommand = true;
+            message.commandName = parts[0];
+            message.commandArgs = parts.slice(1);
+        }
+        return message;
+    }
+    /** Emit 'connected' exactly once per session (on first successful poll). */
+    connectedEmitted = false;
+    onConnectedOnce() {
+        if (!this.connectedEmitted) {
+            this.connectedEmitted = true;
+            this.emit('connected');
+        }
+    }
+    // --------------------------------------------------------------------------
+    // Reconnection
+    // --------------------------------------------------------------------------
+    /**
+     * Recover a dropped connection via the shared ReconnectionManager
+     * (exponential backoff + jitter + exhaustion). `scheduleReconnect` is
+     * single-shot, so a failed attempt re-drives it (deferred past the manager's
+     * internal active-guard) until recovery or exhaustion — same idiom as
+     * irc/imessage.
+     */
+    scheduleReconnect() {
+        if (this.reconnecting || this.closing || !this.running) {
+            return;
+        }
+        if (this.reconnectionManager.listenerCount('exhausted') === 0) {
+            this.reconnectionManager.on('exhausted', () => {
+                this.reconnecting = false;
+                this.running = false;
+                this.emit('disconnected', new Error('Nextcloud Talk reconnection failed after all retries'));
+                logger.error('NextcloudTalkClient: reconnection failed permanently');
+            });
+        }
+        this.reconnecting = true;
+        this.emit('disconnected', new Error('Nextcloud Talk connection dropped'));
+        this.reconnectionManager.scheduleReconnect(async () => {
+            // One probe poll. Success resumes the steady-state loop; failure re-drives
+            // the manager.
+            try {
+                await this.pollOnce();
+                this.reconnecting = false;
+                this.reconnectionManager.onConnected();
+                this.emit('reconnected');
+                this.onConnectedOnce();
+                // Resume the steady-state loop.
+                void this.runPollLoop();
+            }
+            catch (error) {
+                if (this.isAbortError(error) || this.closing || !this.running) {
+                    return; // intentional teardown mid-reconnect
+                }
+                if (this.running && !this.closing) {
+                    setTimeout(() => {
+                        if (this.running && this.reconnecting && !this.closing) {
+                            this.reconnecting = false;
+                            this.scheduleReconnect();
+                        }
+                    }, 0).unref?.();
+                }
+                throw error instanceof Error ? error : new Error(String(error));
+            }
+        });
+    }
+    // --------------------------------------------------------------------------
+    // Send
+    // --------------------------------------------------------------------------
+    async sendMessage(roomToken, text) {
+        const url = `${this.baseUrl}${SPREED_CHAT_PATH}/${encodeURIComponent(roomToken)}`;
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: { ...this.buildHeaders(), 'Content-Type': 'application/json' },
+            body: JSON.stringify({ message: text }),
+        });
+        if (!response.ok) {
+            const body = await response.text().catch(() => '');
+            throw new Error(`Nextcloud Talk send failed: ${response.status} ${response.statusText} - ${body}`);
+        }
+        const envelope = (await response.json().catch(() => ({})));
+        const id = envelope.ocs?.data?.id;
+        return { success: true, messageId: id !== undefined ? String(id) : undefined };
+    }
+    // --------------------------------------------------------------------------
+    // Helpers
+    // --------------------------------------------------------------------------
+    buildHeaders() {
+        const headers = {
+            'OCS-APIRequest': 'true',
+            Accept: 'application/json',
+        };
+        if (this.bearer) {
+            headers.Authorization = `Bearer ${this.bearer}`;
+        }
+        else {
+            const basic = Buffer.from(`${this.username}:${this.password}`).toString('base64');
+            headers.Authorization = `Basic ${basic}`;
+        }
+        return headers;
+    }
+    isAbortError(err) {
+        return (err instanceof Error &&
+            (err.name === 'AbortError' || /aborted/i.test(err.message)));
+    }
+}
 export class NextcloudTalkChannel extends BaseChannel {
-    adapter;
+    client = null;
+    ncConfig;
     constructor(config) {
         super('nextcloud-talk', {
             type: 'nextcloud-talk',
@@ -78,30 +399,60 @@ export class NextcloudTalkChannel extends BaseChannel {
             rateLimit: config.rateLimit,
             options: config.options,
         });
-        this.adapter = new NextcloudTalkAdapter({
-            url: config.url,
-            username: config.username,
-            password: config.password,
-        });
+        this.ncConfig = config;
     }
     async connect() {
-        await this.adapter.start();
-        this.status.connected = true;
-        this.status.authenticated = true;
-        this.status.lastActivity = new Date();
-        this.emit('connected', this.type);
+        const client = new NextcloudTalkClient(this.ncConfig);
+        this.client = client;
+        client.on('message', (message) => {
+            this.status.lastActivity = new Date();
+            this.emit('message', message);
+            if (message.isCommand) {
+                this.emit('command', message);
+            }
+        });
+        // 'connected' fires on the first successful poll — that's when we flip the
+        // channel status to connected (a long-poll can hold open for ~30s, so we do
+        // NOT block connect() on it).
+        client.on('connected', () => {
+            this.status.connected = true;
+            this.status.authenticated = true;
+            this.status.lastActivity = new Date();
+            this.emit('connected', this.type);
+        });
+        client.on('reconnected', () => {
+            this.status.connected = true;
+            this.status.lastActivity = new Date();
+        });
+        client.on('disconnected', (err) => {
+            this.status.connected = false;
+            this.emit('disconnected', this.type, err);
+        });
+        client.on('error', (err) => {
+            this.status.error = err.message;
+            this.emit('error', this.type, err);
+        });
+        client.start();
     }
     async disconnect() {
+        if (this.client) {
+            this.client.stop();
+            this.client.removeAllListeners();
+            this.client = null;
+        }
         if (!this.status.connected)
             return;
-        await this.adapter.stop();
         this.status.connected = false;
         this.status.lastActivity = new Date();
         this.emit('disconnected', this.type);
     }
     async send(message) {
+        if (!this.client) {
+            return { success: false, error: 'Not connected', timestamp: new Date() };
+        }
+        const room = message.channelId || this.client.getRoomToken();
         try {
-            const result = await this.adapter.sendMessage(message.channelId, message.content);
+            const result = await this.client.sendMessage(room, message.content);
             this.status.lastActivity = new Date();
             return {
                 success: result.success,

package/dist/channels/nostr/index.d.ts

@@ -12,7 +12,30 @@ export interface NostrConfig {
 export interface NostrChannelConfig extends ChannelConfig {
     privateKey?: string;
     relays: string[];
+    /** Single relay convenience alias (merged with `relays`). */
+    relay?: string;
+    /** Optional NIP-01 filters merged into the subscription REQ. */
+    filters?: Record<string, unknown>;
+    /** Max reconnection attempts per relay (default 10). */
+    maxRetries?: number;
+    /** Initial reconnect backoff in ms (default 1000). */
+    reconnectDelayMs?: number;
+    /** How long `send()` waits for a relay `OK` ack before failing (default 8000). */
+    publishTimeoutMs?: number;
 }
+/**
+ * A minimal subset of the WHATWG/`ws` WebSocket surface the relay client uses.
+ * Lets us accept the Node global `WebSocket` without pulling in DOM lib types.
+ */
+interface RelaySocket {
+    readyState: number;
+    send(data: string): void;
+    close(code?: number, reason?: string): void;
+    terminate?(): void;
+    addEventListener(type: string, listener: (event: unknown) => void): void;
+}
+/** Factory so tests / runtimes can inject a socket constructor. */
+export type RelaySocketFactory = (url: string) => RelaySocket;
 export declare class NostrAdapter {
     private static readonly BECH32_CHARSET;
     private static readonly BECH32_GENERATOR;
@@ -32,6 +55,13 @@ export declare class NostrAdapter {
     addRelay(url: string): void;
     removeRelay(url: string): void;
     getConfig(): NostrConfig;
+    /**
+     * Resolve the configured secret as raw 32 bytes: 64-char hex as-is, `nsec...`
+     * bech32 decoded to its 32-byte payload, otherwise a deterministic sha256 of
+     * the arbitrary secret. No configured key => a fresh random 32 bytes.
+     * Public so {@link NostrChannel} signs under the *same* identity (esp. nsec).
+     */
+    getSecretKeyBytes(): Buffer;
     private resolvePrivateKeyBytes;
     private encodeBech32;
     private decodeBech32;
@@ -41,11 +71,101 @@ export declare class NostrAdapter {
     private expandBech32Hrp;
     private bech32Polymod;
 }
+/**
+ * Real Nostr relay channel (NIP-01).
+ *
+ * Opens persistent WebSocket connections to each configured relay, subscribes
+ * to kind-1 (text note) events via a `REQ` frame, and surfaces inbound events
+ * as `'message'` events on the channel. Dropped sockets are recovered with the
+ * shared {@link ReconnectionManager} (exponential backoff + jitter), the same
+ * idiom used by the discord/slack/imessage adapters.
+ *
+ * Connection semantics are *optimistic*: `connect()` marks the channel
+ * connected and returns immediately, opening sockets in the background. This
+ * mirrors how a real Nostr client behaves (any one of N relays may be down)
+ * and lets the channel come up even when a relay is unreachable.
+ *
+ * `NostrAdapter` (above) is retained unchanged as the key / bech32 / relay-list
+ * utility — its `start()`/`sendDirectMessage()` are legacy in-process stubs
+ * kept only for the existing unit tests. The real transport lives here.
+ */
 export declare class NostrChannel extends BaseChannel {
     private adapter;
-    constructor(config: NostrChannelConfig);
+    private relays;
+    private readonly subId;
+    private readonly filters;
+    private readonly maxRetries;
+    private readonly reconnectDelayMs;
+    /** Set while an intentional disconnect is in progress so `close` skips reconnect. */
+    private shuttingDown;
+    /** Injectable socket factory (defaults to the Node global `WebSocket`). */
+    private readonly socketFactory;
+    /** Outstanding publishes keyed by event id, resolved on the relay's `OK` ack. */
+    private readonly pendingPublishes;
+    /** How long to wait for a relay `["OK", id, ...]` ack before timing out. */
+    private readonly publishTimeoutMs;
+    constructor(config: NostrChannelConfig, socketFactory?: RelaySocketFactory);
+    /**
+     * Optimistically connect: mark the channel up, emit `'connected'`, then open
+     * every relay socket in the background. Resolves immediately — it never waits
+     * on a socket `'open'`, so an unreachable relay can't block startup.
+     */
     connect(): Promise<void>;
     disconnect(): Promise<void>;
+    /**
+     * Build, BIP-340 sign, and publish a Nostr kind-1 event for the outbound
+     * message.
+     *
+     * When a secret key is configured we derive the x-only `pubkey` and the
+     * Schnorr `sig` via `@noble/curves` (audited secp256k1/BIP-340), compute the
+     * canonical sha256 `id`, publish `["EVENT", event]` to every connected relay,
+     * and resolve from the relay's `["OK", id, accepted, msg]` acknowledgement.
+     *
+     * HONEST GATE: if NO secret key is configured we do NOT sign with a throwaway
+     * key — we return the same clear error as before. Live publishing is gated
+     * only on the operator providing their nsec/hex key + a reachable relay.
+     */
     send(message: OutboundMessage): Promise<DeliveryResult>;
+    /**
+     * Publish a signed event to every open relay socket and resolve from the
+     * FIRST `["OK", id, ...]` acknowledgement (or a timeout). The pending entry is
+     * keyed by event id and resolved by {@link handleRelayData}'s `OK` branch.
+     */
+    private publishToRelays;
+    private openRelay;
+    private scheduleRelayReconnect;
+    private sendSubscription;
+    private handleRelayData;
+    private emitInbound;
+    /**
+     * Build the canonical unsigned Nostr event for `content`. The `id` is the
+     * sha256 of the NIP-01 serialization `[0, pubkey, created_at, kind, tags,
+     * content]`. Used for the honest no-key error path (still surfaces a real id).
+     */
+    private buildUnsignedEvent;
+    /**
+     * Build a fully BIP-340 signed Nostr kind-1 event for `content`.
+     *
+     * `pubkey` and `sig` are derived from the same secp256k1 secret via
+     * `@noble/curves`' Schnorr primitives: `schnorr.getPublicKey` yields the
+     * x-only pubkey (correct BIP-340 even-y normalization), `id` is the sha256 of
+     * the NIP-01 serialization, and `sig = schnorr.sign(id, sk)`. Nostr signs the
+     * 32-byte id directly (no extra pre-hash), which is exactly noble's raw-message
+     * contract — so `schnorr.verify(sig, id, pubkey)` round-trips.
+     */
+    private buildSignedEvent;
+    /** x-only 32-byte public key as lowercase hex (Nostr event `pubkey` field). */
+    private getPublicKeyHex;
+    /**
+     * Resolve the signing secret as raw 32 bytes. Delegates to the adapter's
+     * canonical resolver so hex AND `nsec...` bech32 keys decode to the SAME
+     * identity the operator configured (a duplicated resolver here previously
+     * dropped the nsec branch and silently signed under a sha256-derived key).
+     */
+    private resolvePrivateKeyBytes;
+    private closeSocket;
+    private errorFromEvent;
+    /** Expose the configured relay URLs (post construction). */
+    getRelayUrls(): string[];
 }
 export default NostrAdapter;