twindex-openclaw-plugin 0.4.2 → 0.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "twindex-openclaw-plugin",
-  "version": "0.4.2",
+  "version": "0.5.0",
   "description": "Music intelligence for AI agents. Tours, merch drops, releases, presales.",
   "type": "module",
   "license": "MIT",

package/src/client.ts

@@ -22,6 +22,7 @@ interface Notification {
   twindex_url?: string;
   detail_url?: string;
   created_at: string;
+  read_at?: string | null;
 }
 
 interface Artist {

package/src/index.ts

@@ -1,28 +1,49 @@
+import { readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
 import * as twindex from "./client.js";
-import { createNotificationService } from "./sse-service.js";
+import { createNotificationService } from "./poll-service.js";
+
+let bootstrapping = false;
 
 export default function register(api: any) {
   const cfg = () => api.config?.plugins?.entries?.twindex?.config ?? {};
 
   function persistConfig(updates: Record<string, any>) {
     if (!api.config?.plugins?.entries?.twindex) return;
+    // Update in-memory config
     api.config.plugins.entries.twindex.config = {
       ...cfg(),
       ...updates,
     };
-    api.config.save?.();
+    // Write to disk — OpenClaw plugin API does not expose config.save()
+    try {
+      const configPath = join(homedir(), ".openclaw", "openclaw.json");
+      const raw = readFileSync(configPath, "utf-8");
+      const disk = JSON.parse(raw);
+      if (!disk.plugins) disk.plugins = {};
+      if (!disk.plugins.entries) disk.plugins.entries = {};
+      if (!disk.plugins.entries.twindex) disk.plugins.entries.twindex = {};
+      disk.plugins.entries.twindex.config = api.config.plugins.entries.twindex.config;
+      writeFileSync(configPath, JSON.stringify(disk, null, 2) + "\n", "utf-8");
+      api.logger?.info?.("Twindex: config persisted to disk");
+    } catch (err: any) {
+      api.logger?.warn?.(`Twindex: failed to persist config: ${err.message}`);
+    }
   }
 
-  // ── SSE notification service ──────────────────────────────────────
-  const sseService = createNotificationService(api);
-  api.registerService?.(sseService);
+  // ── Poll-based notification service ──────────────────────────────
+  const pollService = createNotificationService(api);
+  api.registerService?.(pollService);
 
   // ── Auto-bootstrap: register + subscribe ────────────────────────
 
   (async () => {
-    const config = cfg();
-    if (config.artists?.length > 0 && config.frequency && !config.apiKey) {
-      try {
+    if (bootstrapping) return;
+    bootstrapping = true;
+    try {
+      const config = cfg();
+      if (config.artists?.length > 0 && config.frequency && !config.apiKey) {
         const agentId =
           api.agentId ?? api.config?.agentId ?? `openclaw-${crypto.randomUUID()}`;
         const reg = await twindex.register(agentId);
@@ -40,13 +61,15 @@ export default function register(api: any) {
         }
 
         persistConfig({ apiKey });
-        sseService.start();
+        pollService.start();
         api.logger?.info?.(
-          "Twindex: auto-bootstrap complete. Delivery via SSE push.",
+          "Twindex: auto-bootstrap complete. Delivery via polling.",
         );
-      } catch (err: any) {
-        api.logger?.warn?.(`Twindex: auto-bootstrap failed: ${err.message}`);
       }
+    } catch (err: any) {
+      api.logger?.warn?.(`Twindex: auto-bootstrap failed: ${err.message}`);
+    } finally {
+      bootstrapping = false;
     }
   })();
 
@@ -55,7 +78,7 @@ export default function register(api: any) {
   api.registerTool({
     name: "twindex_setup",
     description:
-      "Set up Twindex music notifications. Registers with Twindex, subscribes to artists, and starts real-time push delivery via SSE. Call this after asking your user which artists they want.",
+      "Set up Twindex music notifications. Registers with Twindex, subscribes to artists, and starts polling for updates. Call this after asking your user which artists they want.",
     parameters: {
       type: "object",
       properties: {
@@ -107,8 +130,8 @@ export default function register(api: any) {
           }
         }
 
-        sseService.start();
-        results.push("Real-time push notifications enabled (SSE)");
+        pollService.start();
+        results.push("Notification polling enabled");
 
         return {
           content: [{ type: "text", text: results.join("\n") }],

package/src/poll-service.ts

@@ -0,0 +1,122 @@
+// Polling notification service — replaces SSE for frameworks that can't hold
+// persistent connections (like OpenClaw plugins).
+// Polls GET /api/v1/notifications at configurable intervals, delivers via
+// `openclaw agent` CLI, marks read after confirmed delivery.
+
+import { execFile } from "child_process";
+import * as twindex from "./client.js";
+
+const FREQUENCY_MS: Record<string, number> = {
+  realtime: 5 * 60 * 1000,   // 5 min
+  periodic: 60 * 60 * 1000,  // 1 hour
+  daily: 24 * 60 * 60 * 1000, // 24 hours
+};
+
+function runAgent(message: string): Promise<boolean> {
+  return new Promise((resolve) => {
+    execFile(
+      "openclaw",
+      [
+        "agent",
+        "--session-id",
+        "twindex-push",
+        "--deliver",
+        "--channel",
+        "last",
+        "-m",
+        message,
+      ],
+      { timeout: 120_000 },
+      (err) => resolve(!err),
+    );
+  });
+}
+
+export function createNotificationService(api: any) {
+  let timer: ReturnType<typeof setInterval> | null = null;
+  let running = false;
+  let polling = false; // guard against overlapping polls
+
+  function getApiKey(): string | undefined {
+    return api.config?.plugins?.entries?.twindex?.config?.apiKey;
+  }
+
+  function getFrequency(): string {
+    return api.config?.plugins?.entries?.twindex?.config?.frequency ?? "periodic";
+  }
+
+  const logger = api.logger;
+
+  async function poll() {
+    if (polling) return;
+    polling = true;
+
+    try {
+      const apiKey = getApiKey();
+      if (!apiKey) return;
+
+      const notifications = await twindex.getNotifications(apiKey);
+      if (!notifications || notifications.length === 0) return;
+
+      // Filter to unread only
+      const unread = notifications.filter((n) => !n.read_at);
+      if (unread.length === 0) return;
+
+      logger?.info?.(`Twindex: ${unread.length} unread notification(s)`);
+
+      for (const notif of unread) {
+        const message =
+          `New Twindex update for ${notif.brand} (${notif.event_type}): ${notif.summary}\n` +
+          "Share this with the user naturally. If they seem busy, keep it brief.";
+
+        const delivered = await runAgent(message);
+        if (delivered) {
+          try {
+            await twindex.markRead(apiKey, [notif.id]);
+          } catch {
+            // Non-fatal — delivered but read status will catch up
+          }
+        } else {
+          logger?.warn?.("Twindex: agent delivery failed, will retry next poll");
+          break; // Don't pile up failed deliveries
+        }
+      }
+    } catch (err: any) {
+      logger?.warn?.(`Twindex: poll error — ${err.message}`);
+    } finally {
+      polling = false;
+    }
+  }
+
+  return {
+    id: "twindex-notifications",
+
+    start() {
+      if (running) return;
+      const apiKey = getApiKey();
+      if (!apiKey) {
+        logger?.info?.("Twindex: no API key — poll service waiting for setup");
+        return;
+      }
+
+      running = true;
+      const freq = getFrequency();
+      const intervalMs = FREQUENCY_MS[freq] ?? FREQUENCY_MS.periodic;
+
+      // Immediate first poll
+      poll();
+
+      timer = setInterval(poll, intervalMs);
+      logger?.info?.(`Twindex: poll service started (${freq}, every ${intervalMs / 1000}s)`);
+    },
+
+    stop() {
+      running = false;
+      if (timer) {
+        clearInterval(timer);
+        timer = null;
+      }
+      logger?.info?.("Twindex: poll service stopped");
+    },
+  };
+}