@aitne/daemon 0.1.8 → 0.1.9

package/dist/adapters/telegram-adapter.js

@@ -21,10 +21,8 @@ const TELEGRAM_HTTP_TIMEOUT_MS = 30_000;
  * Group / supergroup traffic is intentionally ignored. This adapter is for
  * owner DMs only; Telegram group mentions are out of scope.
  *
- * Phase 3 — challenge-based pairing only.
- *
- * The adapter no longer has a "first DM wins" discovery mode. Pairing now
- * requires that the daemon register a {@link PairingChallenge} via
+ * Pairing is challenge-based: the daemon must register a
+ * {@link PairingChallenge} via
  * `startPairing()`; only inbound messages whose text passes the matcher
  * (e.g. `/start <random-token>` for QR pairing) capture the owner. This
  * closes the race where any unrelated DM during a 5-minute window could
@@ -37,7 +35,6 @@ export class TelegramAdapter {
     onMessage;
     onOwnerDetected;
     attachmentStore;
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     bot = null;
     botInfo = null;
     /** Active pairing challenge (null when pairing isn't in progress). */
@@ -66,7 +63,7 @@ export class TelegramAdapter {
     startPairing(challenge) {
         this.pairingChallenge = challenge;
         logger.info({ ttlMs: challenge.expiresAt - Date.now() }, "telegram pairing challenge registered");
-        // P2-20: TTL sweep — see SlackAdapter.startPairing for rationale.
+        // TTL sweep — see SlackAdapter.startPairing for rationale.
         const ttlMs = Math.max(0, challenge.expiresAt - Date.now());
         const sweep = setTimeout(() => {
             if (this.pairingChallenge === challenge) {
@@ -113,16 +110,15 @@ export class TelegramAdapter {
     // ── Adapter lifecycle ──────────────────────────────────────────────────
     async start() {
         // Dynamic import — telegraf is an optional dependency
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        let Telegraf;
+        let TelegrafCtor;
         try {
-            const mod = await import("telegraf");
-            Telegraf = mod.Telegraf;
+            const mod = (await import("telegraf"));
+            TelegrafCtor = mod.Telegraf;
         }
         catch {
             throw new Error("telegraf not installed. Run: pnpm --filter @aitne/daemon add telegraf");
         }
-        this.bot = new Telegraf(this.botToken);
+        this.bot = new TelegrafCtor(this.botToken);
         // Validate token + cache bot identity for the dashboard's QR deep link.
         try {
             this.botInfo = await TelegramAdapter.fetchBotInfo(this.botToken);
@@ -130,11 +126,9 @@ export class TelegramAdapter {
         catch (err) {
             logger.warn({ err }, "telegram getMe failed during start");
         }
-        // Generic message handler — covers text, photo, document, audio, voice,
-        // video, etc. The Phase 1 text-only handler is replaced here so that
-        // media-with-caption messages (which do NOT fire the "text" event) are
-        // also captured.
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        // Subscribe to `message`, not `text` — media-with-caption messages
+        // don't fire `text` but do carry user content via `caption`, and a
+        // text-only handler would silently drop them.
         this.bot.on("message", async (ctx) => {
             await this.handleMessage(ctx).catch((err) => {
                 logger.error({ err }, "telegram message handler threw");
@@ -164,7 +158,9 @@ export class TelegramAdapter {
             throw new Error("Telegram bot not started");
         }
         const { channel, text, threadId, attachments } = params;
-        const replyOpts = threadId ? { reply_to_message_id: Number(threadId) } : {};
+        const replyOpts = threadId
+            ? { reply_parameters: { message_id: Number(threadId) } }
+            : {};
         if (!attachments?.length) {
             // Text only — existing behaviour.
             try {
@@ -202,7 +198,6 @@ export class TelegramAdapter {
             isFirst = false;
             try {
                 const buf = readFileSync(att.path);
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
                 let result;
                 if (att.mimeType.startsWith("image/")) {
                     result = await this.bot.telegram.sendPhoto(channel, { source: buf }, caption ? { caption, ...replyOpts } : replyOpts);
@@ -220,7 +215,6 @@ export class TelegramAdapter {
         return { messageId: lastMessageId };
     }
     // ── Inbound message handling ───────────────────────────────────────────
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     async handleMessage(ctx) {
         const msg = ctx.message;
         if (!msg)
@@ -245,7 +239,7 @@ export class TelegramAdapter {
             // completes before pairing is acknowledged. cancelPairing only
             // fires on success — if the callback throws (e.g. .env unwritable)
             // the matcher stays armed so the user can retry by resending the
-            // phrase. See B-1.
+            // phrase.
             const ok = await this.captureOwner(channelId);
             if (ok) {
                 this.cancelPairing();
@@ -393,9 +387,10 @@ export class TelegramAdapter {
             logger.warn({ fileId, fileSizeBytes, maxBytes }, "telegram file exceeds size cap, skipping");
             return null;
         }
+        if (!this.bot)
+            return null;
         let filePath;
         try {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             const fileInfo = await this.bot.telegram.getFile(fileId);
             filePath = fileInfo?.file_path;
         }
@@ -466,26 +461,22 @@ export class TelegramAdapter {
         this.onMessage(event);
     }
     // ── Photo helpers ─────────────────────────────────────────────────────
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     pickLargestPhoto(photos) {
         if (!Array.isArray(photos) || photos.length === 0)
             return "";
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const largest = [...photos].sort((a, b) => (b.file_size ?? 0) - (a.file_size ?? 0))[0];
         return largest?.file_id ?? "";
     }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     photoSizeBytes(photos) {
         if (!Array.isArray(photos) || photos.length === 0)
             return 0;
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const largest = [...photos].sort((a, b) => (b.file_size ?? 0) - (a.file_size ?? 0))[0];
         return largest?.file_size ?? 0;
     }
     /**
      * Atomically promote a chat ID to "owner" and notify the daemon. See
-     * slack-adapter.captureOwner for the full B-1 design rationale — the
-     * env/DB write must complete before we acknowledge pairing, and
+     * slack-adapter.captureOwner for the full rationale — the env/DB
+     * write must complete before we acknowledge pairing, and
      * mutableOwnerId rolls back if the callback throws so a daemon restart
      * doesn't silently lose the binding.
      */
@@ -505,4 +496,3 @@ export class TelegramAdapter {
         }
     }
 }
-//# sourceMappingURL=telegram-adapter.js.map

package/dist/adapters/types.d.ts

@@ -5,8 +5,8 @@ interface SendMessageResult {
 /**
  * Outbound attachment reference — handed to an adapter's `sendMessage` when
  * the agent has generated one or more files during the turn. Each platform
- * adapter translates this into its native upload flow. Phase 1 only wires
- * the Dashboard adapter; other adapters ignore the field until Phase 2.
+ * adapter translates this into its native upload flow. Adapters that have
+ * not yet implemented attachment delivery ignore this field.
  */
 export interface OutboundAttachmentRef {
     id: string;
@@ -61,7 +61,7 @@ export interface MessageAdapter {
         threadId?: string;
         /** Outbound files produced by the agent during this turn. Adapters
          *  that have not yet implemented attachment delivery ignore this
-         *  field; Phase 1 wires only the Dashboard adapter. */
+         *  field. */
         attachments?: OutboundAttachmentRef[];
     }): Promise<SendMessageResult | void>;
     /**
@@ -89,4 +89,3 @@ export interface MessageAdapter {
  */
 export type OnMessageCallback = (event: Event) => void;
 export {};
-//# sourceMappingURL=types.d.ts.map

package/dist/adapters/types.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=types.js.map

package/dist/adapters/whatsapp-adapter.d.ts

@@ -28,16 +28,15 @@ export interface WhatsAppAdapterOptions {
     authDir: string;
     onMessage: OnMessageCallback;
     onLoggedOut?: () => Promise<void> | void;
-    /** Phase 2: canonical attachment store for inbound media download/ingest
-     *  and outbound file delivery. When absent, media is silently skipped. */
+    /** Canonical attachment store for inbound media download/ingest and
+     *  outbound file delivery. When absent, media is silently skipped. */
     attachmentStore?: AttachmentStore;
 }
 export declare function toWhatsAppJid(phone: string): string;
 export declare function extractWhatsAppText(message: Record<string, unknown> | null | undefined): string | null;
 /**
  * WhatsAppAdapter — Baileys-based owner-only WhatsApp DM integration.
- *
- * Phase 1 accepts messages from exactly one configured owner JID.
+ * Accepts messages from exactly one configured owner JID.
  */
 export declare class WhatsAppAdapter implements MessageAdapter {
     readonly platformName = "whatsapp";
@@ -98,6 +97,28 @@ export declare class WhatsAppAdapter implements MessageAdapter {
     private latestQr;
     private lastError;
     private reconnectAttempts;
+    /**
+     * Whether the most recent unsolicited close was a transport/network failure
+     * (see {@link TRANSIENT_NETWORK_STATUS_CODES}) rather than an app-layer
+     * rejection. Read by {@link scheduleReconnect} to decide, once the fast
+     * phase exhausts, whether to enter the never-give-up sustained watch
+     * (network) or surface an error and stop (app-layer).
+     */
+    private lastCloseWasNetwork;
+    /**
+     * True while a reconnect is scheduled OR an attempt (including the sustained
+     * watch's async connectivity probe) is in flight, and we have NOT
+     * permanently given up. Lets the status accessors report "connecting"
+     * during the brief timer-less window of a sustained probe instead of
+     * flashing a red error. Cleared on open / give-up / logout / stop.
+     */
+    private reconnecting;
+    /**
+     * Connectivity probe used by the sustained watch. Injectable so tests can
+     * drive the offline / back-online transitions without real DNS; production
+     * resolves a WhatsApp host through the OS resolver.
+     */
+    private dnsLookup;
     private cachedWAVersion;
     private cachedWAVersionAt;
     constructor(options: WhatsAppAdapterOptions);
@@ -118,10 +139,11 @@ export declare class WhatsAppAdapter implements MessageAdapter {
      *     transitioning). `disabled` covers the pre-connect window during
      *     {@link start}'s awaits.
      *   - `logged_out` → terminal, surface the error.
-     *   - `disconnected` → if a reconnect timer is pending, recovery is in
-     *     flight; otherwise we've either hit `RECONNECT_MAX_ATTEMPTS` or the
-     *     adapter is between attempts with no scheduled retry, both of which
-     *     are real, user-actionable failures.
+     *   - `disconnected` → recovery is in flight when a reconnect timer is
+     *     pending OR a sustained-watch attempt is mid-probe ({@link reconnecting}
+     *     covers the brief timer-less DNS window). Only when neither holds have
+     *     we permanently given up (app-layer rejection past the fast cap) — a
+     *     real, user-actionable failure.
      */
     getStatusError(): string | null;
     getNotificationRuntimeStatus(): NotificationRuntimeStatus;
@@ -195,19 +217,51 @@ export declare class WhatsAppAdapter implements MessageAdapter {
     private connect;
     private handleConnectionUpdate;
     /**
-     * Schedule the next reconnect attempt with full-jitter exponential backoff.
+     * Schedule the next reconnect attempt.
      *
-     * - Delay: `min(initial * factor^attempt, max) + random(0, jitter)`
-     * - Cap: after {@link RECONNECT_MAX_ATTEMPTS} consecutive failures the loop
-     *   stops and the adapter sits in `disconnected` until something external
-     *   (e.g. the dashboard's "Refresh QR" button → `requestQR()`) restarts it.
+     * Two phases:
      *
-     * Why a hard cap: when WhatsApp is blocking us (bad version, throttled IP,
-     * regional outage) every retry burns CPU and risks escalating the block.
-     * Better to surface the error and let the user decide whether to wait it
-     * out or rotate IP / re-pair.
+     *  1. **Fast phase** (`reconnectAttempts < RECONNECT_MAX_ATTEMPTS`) —
+     *     full-jitter exponential backoff, `min(initial * factor^attempt, max) +
+     *     random(0, jitter)`. Recovers quick blips in seconds.
+     *  2. **Sustained watch** (fast phase exhausted, last close was
+     *     network-class) — a fixed long cadence; {@link runReconnectAttempt}
+     *     gates each attempt on a connectivity probe so we only open a socket to
+     *     WhatsApp once the network is back. Never gives up; the attempt counter
+     *     is pinned at the cap to avoid unbounded growth across a long offline
+     *     window. This is what lets a laptop carried out of WiFi range recover
+     *     on its own instead of wedging in an error state.
+     *
+     * If the fast phase exhausts on a *non*-network close (WhatsApp rejecting us
+     * at the app layer — bad version, bad session, throttle) we stop and surface
+     * an error: hammering a relay that keeps closing us is the fast path to an
+     * IP-level block and needs operator action (re-pair / wait it out).
      */
     private scheduleReconnect;
+    /**
+     * Carry out one reconnect attempt. In the sustained watch we first probe
+     * connectivity: if we're still offline, keep watching without poking
+     * WhatsApp (zero ban risk, near-zero cost); once the network is back we
+     * reset to a fresh fast phase and reconnect.
+     *
+     * Why reset the counter on reachability (not just on a clean `open`): when
+     * the network returns, the first reconnect frequently replays WhatsApp's
+     * handshake steps — `restartRequired` (515) and version negotiation — which
+     * close with a *non*-network status and need a few retries to clear. With
+     * the counter still pinned at the cap, that normal 515 would hit
+     * `exhausted && !network` in {@link scheduleReconnect} and falsely give up.
+     * A fresh fast phase gives those handshake closes their proper retry budget
+     * (a clean `open` doesn't fire before a 515, so we can't rely on it here).
+     */
+    private runReconnectAttempt;
+    /**
+     * Cheap connectivity probe for the sustained watch: resolve a WhatsApp host
+     * through the OS resolver. We deliberately do NOT open a socket to the relay
+     * here — a DNS lookup is enough to tell "the laptop has a working network
+     * path again" without poking WhatsApp's servers while we may be throttled or
+     * offline. Fails fast (EAI_AGAIN / ENOTFOUND) when there is no network.
+     */
+    private isNetworkReachable;
     private handleMessagesUpsert;
     private handleIncomingMessage;
     private extractAndIngestWhatsAppMedia;
@@ -243,4 +297,3 @@ export declare class WhatsAppAdapter implements MessageAdapter {
      */
     private closeSocket;
 }
-//# sourceMappingURL=whatsapp-adapter.d.ts.map