@lovenyberg/ove 0.2.1 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lovenyberg/ove",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "Your grumpy but meticulous dev companion. AI coding agent for Slack, WhatsApp, Telegram, Discord, GitHub, HTTP API, and CLI.",
   "type": "module",
   "bin": {
@@ -32,7 +32,7 @@
   },
   "dependencies": {
     "@slack/bolt": "^4.1.0",
-    "baileys": "^6.7.0",
+    "baileys": "^7.0.0-rc.9",
     "discord.js": "^14.25.1",
     "grammy": "^1.40.0",
     "qrcode-terminal": "^0.12.0"

package/src/adapters/debounce.ts

@@ -0,0 +1,10 @@
+export function debounce<T extends (...args: any[]) => any>(fn: T, ms: number): T {
+  let timer: ReturnType<typeof setTimeout> | null = null;
+  return ((...args: any[]) => {
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(() => {
+      timer = null;
+      fn(...args);
+    }, ms);
+  }) as any as T;
+}

package/src/adapters/discord.ts

@@ -1,17 +1,7 @@
 import { Client, GatewayIntentBits, type Message } from "discord.js";
 import type { ChatAdapter, IncomingMessage } from "./types";
 import { logger } from "../logger";
-
-function debounce<T extends (...args: any[]) => any>(fn: T, ms: number): T {
-  let timer: ReturnType<typeof setTimeout> | null = null;
-  return ((...args: any[]) => {
-    if (timer) clearTimeout(timer);
-    timer = setTimeout(() => {
-      timer = null;
-      fn(...args);
-    }, ms);
-  }) as any as T;
-}
+import { debounce } from "./debounce";
 
 export class DiscordAdapter implements ChatAdapter {
   private client: Client;

package/src/adapters/github.ts

@@ -115,6 +115,18 @@ export class GitHubAdapter implements EventAdapter {
       logger.info("github mention detected", { repo, user: comment.user.login, number });
       this.onEvent?.(event);
     }
+
+    this.pruneSeenIds();
+  }
+
+  private pruneSeenIds() {
+    if (this.seenCommentIds.size > 1000) {
+      const iter = this.seenCommentIds.values();
+      while (this.seenCommentIds.size > 800) {
+        const val = iter.next().value;
+        if (val !== undefined) this.seenCommentIds.delete(val);
+      }
+    }
   }
 
   private async fetchRecentComments(repo: string): Promise<GitHubComment[]> {

package/src/adapters/http.ts

@@ -94,7 +94,8 @@ export class HttpApiAdapter implements EventAdapter {
               controller.enqueue(`data: ${data}\n\n`);
             },
             cancel() {
-              // Clean up on disconnect
+              const idx = pending.sseControllers.indexOf(controller);
+              if (idx >= 0) pending.sseControllers.splice(idx, 1);
             },
           });
 
@@ -146,9 +147,14 @@ export class HttpApiAdapter implements EventAdapter {
       try {
         controller.enqueue(`data: ${data}\n\n`);
         controller.close();
-      } catch {}
+      } catch (err) {
+        logger.debug("sse enqueue failed", { eventId, error: String(err) });
+      }
     }
     pending.sseControllers = [];
+
+    // Clean up event after 5 minutes
+    setTimeout(() => this.events.delete(eventId), 5 * 60 * 1000);
   }
 
   /** Called by index.ts to push status updates to SSE clients */
@@ -161,7 +167,9 @@ export class HttpApiAdapter implements EventAdapter {
     for (const controller of pending.sseControllers) {
       try {
         controller.enqueue(`data: ${data}\n\n`);
-      } catch {}
+      } catch (err) {
+        logger.debug("sse status update failed", { eventId, error: String(err) });
+      }
     }
   }
 }

package/src/adapters/slack.ts

@@ -2,17 +2,7 @@
 import { App } from "@slack/bolt";
 import type { ChatAdapter, IncomingMessage } from "./types";
 import { logger } from "../logger";
-
-function debounce<T extends (...args: any[]) => any>(fn: T, ms: number): T {
-  let timer: ReturnType<typeof setTimeout> | null = null;
-  return ((...args: any[]) => {
-    if (timer) clearTimeout(timer);
-    timer = setTimeout(() => {
-      timer = null;
-      fn(...args);
-    }, ms);
-  }) as any as T;
-}
+import { debounce } from "./debounce";
 
 export class SlackAdapter implements ChatAdapter {
   private app: App;

package/src/adapters/telegram.ts

@@ -1,16 +1,24 @@
 import { Bot } from "grammy";
 import type { ChatAdapter, IncomingMessage } from "./types";
 import { logger } from "../logger";
+import { debounce } from "./debounce";
 
-function debounce<T extends (...args: any[]) => any>(fn: T, ms: number): T {
-  let timer: ReturnType<typeof setTimeout> | null = null;
-  return ((...args: any[]) => {
-    if (timer) clearTimeout(timer);
-    timer = setTimeout(() => {
-      timer = null;
-      fn(...args);
-    }, ms);
-  }) as any as T;
+/** Convert simple markdown (*bold*, `code`, ```blocks```) to Telegram HTML */
+function mdToHtml(text: string): string {
+  // Escape HTML entities first
+  let html = text
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;');
+
+  return html
+    // Code blocks first (```lang\n...\n```)
+    .replace(/```(\w*)\n([\s\S]*?)```/g, '<pre>$2</pre>')
+    // Inline code
+    .replace(/`([^`]+)`/g, '<code>$1</code>')
+    // Bold **text** or *text*
+    .replace(/\*\*(.+?)\*\*/g, '<b>$1</b>')
+    .replace(/\*(.+?)\*/g, '<b>$1</b>');
 }
 
 export class TelegramAdapter implements ChatAdapter {
@@ -30,18 +38,21 @@ export class TelegramAdapter implements ChatAdapter {
       const userId = `telegram:${ctx.from.id}`;
       const text = ctx.message.text;
       let statusMsgId: number | undefined;
+      let lastStatusText: string | undefined;
 
       const doUpdate = debounce(async (statusText: string) => {
+        if (statusText === lastStatusText) return; // skip unchanged text
+        lastStatusText = statusText;
+        const html = mdToHtml(statusText);
         try {
           if (statusMsgId) {
-            await ctx.api.editMessageText(chatId, statusMsgId, statusText);
+            await ctx.api.editMessageText(chatId, statusMsgId, html, { parse_mode: "HTML" });
           } else {
-            const sent = await ctx.reply(statusText);
+            const sent = await ctx.reply(html, { parse_mode: "HTML" });
             statusMsgId = sent.message_id;
           }
         } catch {
-          const sent = await ctx.reply(statusText);
-          statusMsgId = sent.message_id;
+          // Edit may fail if content unchanged or message too old — ignore
         }
       }, 3000);
 
@@ -50,7 +61,18 @@ export class TelegramAdapter implements ChatAdapter {
         platform: "telegram",
         text,
         reply: async (replyText: string) => {
-          await ctx.reply(replyText);
+          // Replace the status message with the first reply, then send new messages for the rest
+          if (statusMsgId) {
+            try {
+              await ctx.api.editMessageText(chatId, statusMsgId, mdToHtml(replyText), { parse_mode: "HTML" });
+              statusMsgId = undefined;
+              return;
+            } catch {
+              // Edit failed (message too old, etc.) — fall through to send new
+            }
+            statusMsgId = undefined;
+          }
+          await ctx.reply(mdToHtml(replyText), { parse_mode: "HTML" });
         },
         updateStatus: doUpdate,
       };
@@ -70,6 +92,6 @@ export class TelegramAdapter implements ChatAdapter {
 
   async sendToUser(userId: string, text: string): Promise<void> {
     const chatId = userId.replace("telegram:", "");
-    await this.bot.api.sendMessage(Number(chatId), text);
+    await this.bot.api.sendMessage(Number(chatId), mdToHtml(text), { parse_mode: "HTML" });
   }
 }

package/src/adapters/whatsapp.ts

@@ -11,9 +11,13 @@ export class WhatsAppAdapter implements ChatAdapter {
   private sock: WASocket | null = null;
   private onMessage?: (msg: IncomingMessage) => void;
   private authDir: string;
+  private phoneNumber?: string;
+  private reconnectAttempt = 0;
+  private sentByBot = new Set<string>();
 
-  constructor(authDir: string = "./auth/whatsapp") {
-    this.authDir = authDir;
+  constructor(opts: { authDir?: string; phoneNumber?: string } = {}) {
+    this.authDir = opts.authDir ?? "./auth/whatsapp";
+    this.phoneNumber = opts.phoneNumber;
   }
 
   async start(onMessage: (msg: IncomingMessage) => void): Promise<void> {
@@ -23,28 +27,56 @@ export class WhatsAppAdapter implements ChatAdapter {
 
     this.sock = makeWASocket({
       auth: state,
-      printQRInTerminal: true,
     });
 
     this.sock.ev.on("creds.update", saveCreds);
 
-    this.sock.ev.on("connection.update", ({ connection, lastDisconnect }) => {
+    let pairingRequested = false;
+
+    this.sock.ev.on("connection.update", async ({ connection, lastDisconnect, qr }) => {
+      // Request pairing code when server is ready (sends qr event)
+      if (qr && this.phoneNumber && !pairingRequested) {
+        pairingRequested = true;
+        try {
+          const phone = this.phoneNumber.replace(/[^0-9]/g, "");
+          const code = await this.sock!.requestPairingCode(phone);
+          logger.info(`whatsapp pairing code: ${code}`, { phone });
+          console.log(`\n  WhatsApp pairing code: ${code}`);
+          console.log(`  Enter this code on your phone: WhatsApp → Linked Devices → Link a Device\n`);
+        } catch (err) {
+          logger.error("failed to request pairing code", { error: String(err) });
+        }
+      }
+
       if (connection === "close") {
         const statusCode = (lastDisconnect?.error as any)?.output?.statusCode;
         if (statusCode !== DisconnectReason.loggedOut) {
-          logger.warn("whatsapp disconnected, reconnecting...", { statusCode });
-          this.start(onMessage);
+          this.reconnectAttempt++;
+          const delay = Math.min(2000 * this.reconnectAttempt, 30_000);
+          logger.warn("whatsapp disconnected, reconnecting...", { statusCode, delay });
+          setTimeout(() => this.start(onMessage), delay);
         } else {
           logger.error("whatsapp logged out");
         }
       } else if (connection === "open") {
+        this.reconnectAttempt = 0;
         logger.info("whatsapp adapter connected");
       }
     });
 
     this.sock.ev.on("messages.upsert", ({ messages }) => {
       for (const waMsg of messages) {
-        if (!waMsg.message || waMsg.key.fromMe) continue;
+        if (!waMsg.message) continue;
+
+        // Skip messages sent by the bot (replies/status updates)
+        const msgId = waMsg.key.id;
+        if (msgId && this.sentByBot.has(msgId)) {
+          this.sentByBot.delete(msgId);
+          continue;
+        }
+
+        // Skip messages from others (not our phone) — we only process our own commands
+        if (!waMsg.key.fromMe) continue;
 
         const text =
           waMsg.message.conversation ||
@@ -54,7 +86,10 @@ export class WhatsAppAdapter implements ChatAdapter {
         const jid = waMsg.key.remoteJid;
         if (!jid) continue;
 
-        const phone = jid.split("@")[0];
+        // For fromMe messages, use our configured phone number
+        const phone = waMsg.key.fromMe
+          ? (this.phoneNumber?.replace(/[^0-9]/g, "") ?? jid.split("@")[0])
+          : jid.split("@")[0];
         const userId = `whatsapp:${phone}`;
 
         // Batch status updates: at most once per 10 seconds
@@ -64,7 +99,8 @@ export class WhatsAppAdapter implements ChatAdapter {
 
         const flushStatus = async () => {
           if (pendingStatus && this.sock) {
-            await this.sock.sendMessage(jid, { text: pendingStatus });
+            const sent = await this.sock.sendMessage(jid, { text: pendingStatus });
+            if (sent?.key?.id) this.sentByBot.add(sent.key.id);
             lastSentAt = Date.now();
             pendingStatus = null;
           }
@@ -82,7 +118,8 @@ export class WhatsAppAdapter implements ChatAdapter {
               batchTimer = null;
               pendingStatus = null;
             }
-            await this.sock?.sendMessage(jid, { text: replyText });
+            const sent = await this.sock?.sendMessage(jid, { text: replyText });
+            if (sent?.key?.id) this.sentByBot.add(sent.key.id);
           },
           updateStatus: async (statusText: string) => {
             pendingStatus = statusText;
@@ -113,6 +150,7 @@ export class WhatsAppAdapter implements ChatAdapter {
   async sendToUser(userId: string, text: string): Promise<void> {
     const phone = userId.replace("whatsapp:", "");
     const jid = `${phone}@s.whatsapp.net`;
-    await this.sock?.sendMessage(jid, { text });
+    const sent = await this.sock?.sendMessage(jid, { text });
+    if (sent?.key?.id) this.sentByBot.add(sent.key.id);
   }
 }

package/src/config.test.ts

@@ -1,7 +1,18 @@
 import { describe, it, expect, beforeEach, afterEach } from "bun:test";
 import { loadConfig, isAuthorized, getUserRepos, saveConfig, addRepo, addUser } from "./config";
+import type { Config } from "./config";
 import { readFileSync, writeFileSync, unlinkSync } from "node:fs";
 
+function makeConfig(overrides: Partial<Config> = {}): Config {
+  return {
+    repos: {},
+    users: {},
+    claude: { maxTurns: 25 },
+    reposDir: "./repos",
+    ...overrides,
+  };
+}
+
 describe("loadConfig", () => {
   it("returns config with repos and users", () => {
     const config = loadConfig();
@@ -99,3 +110,62 @@ describe("saveConfig / addRepo / addUser", () => {
     expect(config.users["slack:U1"].repos).toEqual(["a", "b", "c"]);
   });
 });
+
+describe("wildcard auth", () => {
+  it("grants access to any repo with wildcard", () => {
+    const config = makeConfig({
+      users: { "tg:123": { name: "love", repos: ["*"] } },
+    });
+    expect(isAuthorized(config, "tg:123", "any-repo")).toBe(true);
+    expect(isAuthorized(config, "tg:123", "another-repo")).toBe(true);
+  });
+
+  it("still works with explicit repo list", () => {
+    const config = makeConfig({
+      users: { "tg:123": { name: "love", repos: ["my-app"] } },
+    });
+    expect(isAuthorized(config, "tg:123", "my-app")).toBe(true);
+    expect(isAuthorized(config, "tg:123", "other")).toBe(false);
+  });
+
+  it("denies unknown user", () => {
+    const config = makeConfig();
+    expect(isAuthorized(config, "unknown", "repo")).toBe(false);
+  });
+
+  it("allows user without repo check", () => {
+    const config = makeConfig({
+      users: { "tg:123": { name: "love", repos: [] } },
+    });
+    expect(isAuthorized(config, "tg:123")).toBe(true);
+  });
+});
+
+describe("getUserRepos with wildcard", () => {
+  it("returns ['*'] when user has wildcard", () => {
+    const config = makeConfig({
+      users: { "tg:123": { name: "love", repos: ["*"] } },
+    });
+    expect(getUserRepos(config, "tg:123")).toEqual(["*"]);
+  });
+
+  it("returns empty for unknown user", () => {
+    const config = makeConfig();
+    expect(getUserRepos(config, "unknown")).toEqual([]);
+  });
+});
+
+describe("github config type", () => {
+  it("accepts github config on Config", () => {
+    const config = makeConfig({
+      github: { syncInterval: 60000, orgs: ["my-org"] },
+    });
+    expect(config.github!.syncInterval).toBe(60000);
+    expect(config.github!.orgs).toEqual(["my-org"]);
+  });
+
+  it("github config is optional", () => {
+    const config = makeConfig();
+    expect(config.github).toBeUndefined();
+  });
+});

package/src/config.ts

@@ -6,9 +6,10 @@ export interface RunnerConfig {
 }
 
 export interface RepoConfig {
-  url: string;
-  defaultBranch: string;
+  url?: string;
+  defaultBranch?: string;
   runner?: RunnerConfig;
+  excluded?: boolean;
 }
 
 export interface UserConfig {
@@ -30,6 +31,11 @@ export interface CronTaskConfig {
   userId: string;
 }
 
+export interface GitHubConfig {
+  syncInterval?: number;
+  orgs?: string[];
+}
+
 export interface Config {
   repos: Record<string, RepoConfig>;
   users: Record<string, UserConfig>;
@@ -40,6 +46,7 @@ export interface Config {
   mcpServers?: Record<string, McpServerConfig>;
   cron?: CronTaskConfig[];
   runner?: RunnerConfig;
+  github?: GitHubConfig;
 }
 
 export function loadConfig(): Config {
@@ -54,8 +61,10 @@ export function loadConfig(): Config {
       mcpServers: raw.mcpServers,
       cron: raw.cron,
       runner: raw.runner,
+      github: raw.github,
     };
   } catch {
+    // Config file doesn't exist yet or is invalid — use defaults
     return {
       repos: {},
       users: {},
@@ -77,7 +86,7 @@ export function isAuthorized(config: Config, platformUserId: string, repo?: stri
   const user = config.users[platformUserId];
   if (!user) return false;
   if (!repo) return true;
-  return user.repos.includes(repo);
+  return user.repos.includes("*") || user.repos.includes(repo);
 }
 
 export function saveConfig(config: Config): void {
@@ -86,11 +95,14 @@ export function saveConfig(config: Config): void {
   let existing: Record<string, any> = {};
   try {
     existing = JSON.parse(readFileSync(configPath, "utf-8"));
-  } catch {}
+  } catch {
+    // File doesn't exist yet or is invalid — start with empty object
+  }
   const merged = { ...existing, repos: config.repos, users: config.users, claude: config.claude, reposDir: config.reposDir };
   if (config.mcpServers) merged.mcpServers = config.mcpServers;
   if (config.cron) merged.cron = config.cron;
   if (config.runner) merged.runner = config.runner;
+  if (config.github) merged.github = config.github;
   writeFileSync(configPath, JSON.stringify(merged, null, 2) + "\n");
 }