twindex-openclaw-plugin 0.8.5 → 0.8.20260410

package/openclaw.plugin.json

@@ -1,8 +1,8 @@
 {
-  "id": "twindex",
+  "id": "twindex-openclaw-plugin",
   "name": "New Lore",
   "description": "Music intelligence for AI agents. Get notified about tours, merch drops, releases, and presales for your favorite artists.",
-  "version": "0.8.5",
+  "version": "0.8.20260410",
   "skills": ["./skills"],
   "configSchema": {
     "type": "object",

package/package.json

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

package/src/index.ts

@@ -1,40 +1,26 @@
-import { readFileSync, writeFileSync, readdirSync, statSync } from "fs";
+import { readFileSync, readdirSync, statSync } from "fs";
 import { join } from "path";
 import { homedir } from "os";
 import * as twindex from "./client.js";
 import { createNotificationService } from "./poll-service.js";
-import { mergedPluginConfig } from "./config.js";
+import {
+  getPluginConfig,
+  migrateLegacyPluginConfig,
+  persistPluginConfig,
+} from "./plugin-config.js";
 
 let bootstrapping = false;
 
 export default function register(api: any) {
-  const cfg = () => mergedPluginConfig(api);
+  const cfg = () => getPluginConfig(api);
 
-  function persistConfig(updates: Record<string, any>) {
-    const nextConfig = {
-      ...cfg(),
-      ...updates,
-    };
-
-    // Update in-memory config when the plugin entry is available.
-    if (api.config?.plugins?.entries?.twindex) {
-      api.config.plugins.entries.twindex.config = nextConfig;
-    }
+  if (migrateLegacyPluginConfig(api)) {
+    api.logger?.info?.("NewLore: migrated legacy twindex plugin config");
+  }
 
-    // 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 = nextConfig;
-      writeFileSync(configPath, JSON.stringify(disk, null, 2) + "\n", "utf-8");
-      api.logger?.info?.("NewLore: config persisted to disk");
-    } catch (err: any) {
-      api.logger?.warn?.(`NewLore: failed to persist config: ${err.message}`);
-    }
+  function persistConfig(updates: Record<string, any>) {
+    persistPluginConfig(api, updates);
+    api.logger?.info?.("NewLore: config persisted to disk");
   }
 
   // ── Poll-based notification service ──────────────────────────────
@@ -74,7 +60,7 @@ export default function register(api: any) {
     bootstrapping = true;
     try {
       const config = cfg();
-      if (config.artists?.length > 0 && config.frequency && !config.apiKey) {
+      if (config.artists?.length > 0 && !config.apiKey) {
         const agentId =
           api.agentId ?? api.config?.agentId ?? `openclaw-${crypto.randomUUID()}`;
         const reg = await twindex.register(agentId);
@@ -92,7 +78,10 @@ export default function register(api: any) {
         }
 
         // Auto-detect chatTarget from channel config if not explicitly set
-        const updates: Record<string, any> = { apiKey };
+        const updates: Record<string, any> = {
+          apiKey,
+          frequency: config.frequency ?? "periodic",
+        };
         const chatTarget = inferChatTarget();
         if (chatTarget) {
           updates.chatTarget = chatTarget;
@@ -158,7 +147,7 @@ export default function register(api: any) {
         chat_target: {
           type: "string",
           description:
-            "Delivery target. For Telegram, this is the chat ID. For Slack, the channel ID.",
+            "Optional. Delivery target. For Telegram, this is the chat ID. For Slack, the channel ID. When omitted, the plugin infers it from the active channel config.",
         },
         chat_channel: {
           type: "string",
@@ -172,15 +161,35 @@ export default function register(api: any) {
             "User's preferred city for tour notifications (e.g. 'san-francisco', 'new-york', 'london'). When set, tour notifications highlight shows in this city.",
         },
       },
-      required: ["artists", "frequency", "chat_target"],
+      required: ["artists"],
     },
     async execute(
       _id: string,
-      params: { artists: string[]; frequency: string; chat_target: string; chat_channel?: string; city?: string },
+      params: {
+        artists: string[];
+        frequency?: string;
+        chat_target?: string;
+        chat_channel?: string;
+        city?: string;
+      },
     ) {
       try {
         const config = cfg();
         let apiKey = config.apiKey;
+        const frequency = params.frequency ?? config.frequency ?? "periodic";
+        const chatTarget = params.chat_target ?? inferChatTarget();
+        const chatChannel = params.chat_channel ?? inferChatChannel();
+
+        if (!chatTarget) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "Setup needs a delivery target. Message me from Telegram or Slack first, or pass chat_target explicitly.",
+              },
+            ],
+          };
+        }
 
         if (!apiKey) {
           const agentId =
@@ -194,10 +203,10 @@ export default function register(api: any) {
         persistConfig({
           apiKey,
           artists: params.artists,
-          frequency: params.frequency,
-          chatTarget: params.chat_target,
-          chatChannel: params.chat_channel ?? "telegram",
-          city: params.city ?? "",
+          frequency,
+          chatTarget,
+          chatChannel,
+          city: params.city ?? config.city ?? "",
         });
 
         if (params.city) {
@@ -220,6 +229,7 @@ export default function register(api: any) {
 
         pollService.start();
         results.push("Notification polling enabled");
+        results.push(`Delivery: ${chatChannel}:${chatTarget}`);
 
         return {
           content: [{ type: "text", text: results.join("\n") }],

package/src/plugin-config.ts

@@ -0,0 +1,159 @@
+import { readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+
+const LEGACY_PLUGIN_IDS = ["twindex"];
+
+export type NewLorePluginConfig = {
+  apiKey?: string;
+  artists?: string[];
+  frequency?: string;
+  chatTarget?: string;
+  chatChannel?: string;
+  city?: string;
+};
+
+function isRecord(value: unknown): value is Record<string, any> {
+  return typeof value === "object" && value !== null;
+}
+
+function resolveLegacyConfig(api: any): NewLorePluginConfig | undefined {
+  const entries = api?.config?.plugins?.entries;
+  if (!isRecord(entries)) return undefined;
+  for (const pluginId of LEGACY_PLUGIN_IDS) {
+    const legacyConfig = entries[pluginId]?.config;
+    if (isRecord(legacyConfig) && Object.keys(legacyConfig).length > 0) {
+      return legacyConfig as NewLorePluginConfig;
+    }
+  }
+  return undefined;
+}
+
+function ensurePluginEntry(api: any, pluginId: string): Record<string, any> {
+  if (!isRecord(api.config)) api.config = {};
+  if (!isRecord(api.config.plugins)) api.config.plugins = {};
+  if (!isRecord(api.config.plugins.entries)) api.config.plugins.entries = {};
+  if (!isRecord(api.config.plugins.entries[pluginId])) {
+    api.config.plugins.entries[pluginId] = {};
+  }
+  return api.config.plugins.entries[pluginId];
+}
+
+function pruneLegacyPluginState(target: any, pluginId: string): boolean {
+  if (!isRecord(target?.plugins) || LEGACY_PLUGIN_IDS.includes(pluginId)) {
+    return false;
+  }
+
+  let changed = false;
+
+  if (isRecord(target.plugins.entries)) {
+    for (const legacyPluginId of LEGACY_PLUGIN_IDS) {
+      if (legacyPluginId !== pluginId && legacyPluginId in target.plugins.entries) {
+        delete target.plugins.entries[legacyPluginId];
+        changed = true;
+      }
+    }
+  }
+
+  if (isRecord(target.plugins.installs)) {
+    for (const legacyPluginId of LEGACY_PLUGIN_IDS) {
+      if (legacyPluginId !== pluginId && legacyPluginId in target.plugins.installs) {
+        delete target.plugins.installs[legacyPluginId];
+        changed = true;
+      }
+    }
+  }
+
+  return changed;
+}
+
+function persistConfigToDisk(
+  pluginId: string,
+  nextConfig?: NewLorePluginConfig,
+): boolean {
+  const configPath = join(homedir(), ".openclaw", "openclaw.json");
+  const raw = readFileSync(configPath, "utf-8");
+  const disk = JSON.parse(raw);
+  let changed = false;
+
+  if (nextConfig) {
+    if (!isRecord(disk.plugins)) disk.plugins = {};
+    if (!isRecord(disk.plugins.entries)) disk.plugins.entries = {};
+    if (!isRecord(disk.plugins.entries[pluginId])) disk.plugins.entries[pluginId] = {};
+    disk.plugins.entries[pluginId].config = nextConfig;
+    changed = true;
+  }
+
+  changed = pruneLegacyPluginState(disk, pluginId) || changed;
+
+  if (changed) {
+    writeFileSync(configPath, JSON.stringify(disk, null, 2) + "\n", "utf-8");
+  }
+
+  return changed;
+}
+
+export function getPluginId(api: any): string {
+  if (typeof api?.id === "string" && api.id.trim()) return api.id.trim();
+  return LEGACY_PLUGIN_IDS[0];
+}
+
+export function getPluginConfig(api: any): NewLorePluginConfig {
+  if (isRecord(api?.pluginConfig) && Object.keys(api.pluginConfig).length > 0) {
+    return api.pluginConfig as NewLorePluginConfig;
+  }
+
+  const pluginId = getPluginId(api);
+  const currentConfig = api?.config?.plugins?.entries?.[pluginId]?.config;
+  if (isRecord(currentConfig) && Object.keys(currentConfig).length > 0) {
+    return currentConfig as NewLorePluginConfig;
+  }
+
+  return resolveLegacyConfig(api) ?? {};
+}
+
+export function persistPluginConfig(
+  api: any,
+  updates: Record<string, any>,
+): NewLorePluginConfig {
+  const pluginId = getPluginId(api);
+  const nextConfig = {
+    ...getPluginConfig(api),
+    ...updates,
+  };
+
+  ensurePluginEntry(api, pluginId).config = nextConfig;
+  pruneLegacyPluginState(api.config, pluginId);
+  api.pluginConfig = nextConfig;
+
+  // OpenClaw does not currently expose a config.save() helper to plugins.
+  try {
+    persistConfigToDisk(pluginId, nextConfig);
+  } catch (err: any) {
+    api.logger?.warn?.(`NewLore: failed to persist config: ${err.message}`);
+  }
+
+  return nextConfig;
+}
+
+export function migrateLegacyPluginConfig(api: any): boolean {
+  const pluginId = getPluginId(api);
+  if (LEGACY_PLUGIN_IDS.includes(pluginId)) return false;
+
+  const currentConfig = api?.config?.plugins?.entries?.[pluginId]?.config;
+  if (isRecord(currentConfig) && Object.keys(currentConfig).length > 0) {
+    api.pluginConfig = currentConfig;
+    try {
+      return pruneLegacyPluginState(api.config, pluginId) || persistConfigToDisk(pluginId);
+    } catch (err: any) {
+      api.logger?.warn?.(`NewLore: failed to prune legacy config: ${err.message}`);
+      return false;
+    }
+  }
+
+  const legacyConfig = resolveLegacyConfig(api);
+  if (!legacyConfig) return false;
+
+  persistPluginConfig(api, legacyConfig);
+  return true;
+}

package/src/poll-service.ts

@@ -5,7 +5,7 @@
 
 import { execFile } from "child_process";
 import * as twindex from "./client.js";
-import { mergedPluginConfig } from "./config.js";
+import { getPluginConfig, getPluginId } from "./plugin-config.js";
 
 const FREQUENCY_MS: Record<string, number> = {
   realtime: 20 * 1000,        // 20 sec (demo speed)
@@ -13,43 +13,25 @@ const FREQUENCY_MS: Record<string, number> = {
   daily: 24 * 60 * 60 * 1000, // 24 hours
 };
 
-const INITIAL_POLL_DELAY_MS = 15 * 1000;
-const MESSAGE_SEND_TIMEOUT_MS = 30 * 1000;
-
 function sendMessage(
   message: string,
   channel: string,
   target: string,
-): Promise<{ ok: boolean; reason?: string }> {
+): Promise<boolean> {
   return new Promise((resolve) => {
     execFile(
       "openclaw",
       ["message", "send", "--channel", channel, "--target", target, "-m", message],
-      { timeout: MESSAGE_SEND_TIMEOUT_MS },
-      (err, stdout, stderr) => {
-        if (!err) {
-          resolve({ ok: true });
-          return;
-        }
-
-        const details = [err.message, stderr?.trim(), stdout?.trim()]
-          .filter(Boolean)
-          .join(" | ");
-        resolve({ ok: false, reason: details || "unknown delivery error" });
-      },
+      { timeout: 30_000 },
+      (err) => resolve(!err),
     );
   });
 }
 
 export function createNotificationService(api: any) {
   let timer: ReturnType<typeof setInterval> | null = null;
-  let startupPoll: ReturnType<typeof setTimeout> | null = null;
-  let running = false;
   let polling = false; // guard against overlapping polls
-
-  function cfg(): Record<string, any> {
-    return mergedPluginConfig(api);
-  }
+  const cfg = () => getPluginConfig(api);
 
   function getApiKey(): string | undefined {
     return cfg().apiKey;
@@ -157,17 +139,15 @@ export function createNotificationService(api: any) {
           message += `\n\nWant to see how it looks on you? Send me a selfie and I'll show you.`;
         }
 
-        const delivery = await sendMessage(message, channel, target);
-        if (delivery.ok) {
+        const delivered = await sendMessage(message, channel, target);
+        if (delivered) {
           try {
             await twindex.markRead(apiKey, [notif.id]);
           } catch {
             // Non-fatal — delivered but read status will catch up
           }
         } else {
-          logger?.warn?.(
-            `Twindex: message delivery failed, will retry next poll (${delivery.reason})`,
-          );
+          logger?.warn?.("Twindex: message delivery failed, will retry next poll");
           break; // Don't pile up failed deliveries
         }
       }
@@ -179,7 +159,7 @@ export function createNotificationService(api: any) {
   }
 
   return {
-    id: "twindex-notifications",
+    id: `${getPluginId(api)}-notifications`,
 
     start() {
       // Clear any stale timer from a previous gateway reload
@@ -187,10 +167,6 @@ export function createNotificationService(api: any) {
         clearInterval(timer);
         timer = null;
       }
-      if (startupPoll) {
-        clearTimeout(startupPoll);
-        startupPoll = null;
-      }
 
       const apiKey = getApiKey();
       if (!apiKey) {
@@ -198,31 +174,21 @@ export function createNotificationService(api: any) {
         return;
       }
 
-      running = true;
       const freq = getFrequency();
       const intervalMs = FREQUENCY_MS[freq] ?? FREQUENCY_MS.periodic;
 
+      // Immediate first poll
+      poll();
+
       timer = setInterval(poll, intervalMs);
-      const initialDelay = Math.min(INITIAL_POLL_DELAY_MS, intervalMs);
-      startupPoll = setTimeout(() => {
-        startupPoll = null;
-        poll();
-      }, initialDelay);
-      logger?.info?.(
-        `Twindex: poll service started (${freq}, every ${intervalMs / 1000}s, initial delay ${initialDelay / 1000}s)`,
-      );
+      logger?.info?.(`Twindex: poll service started (${freq}, every ${intervalMs / 1000}s)`);
     },
 
     stop() {
-      running = false;
       if (timer) {
         clearInterval(timer);
         timer = null;
       }
-      if (startupPoll) {
-        clearTimeout(startupPoll);
-        startupPoll = null;
-      }
       logger?.info?.("Twindex: poll service stopped");
     },
   };

package/src/sse-service.ts

@@ -4,6 +4,7 @@
 
 import { execFile } from "child_process";
 import * as twindex from "./client.js";
+import { getPluginConfig, getPluginId } from "./plugin-config.js";
 
 const BASE_URL = "https://newlore.ai";
 const BACKOFF_STEPS = [1000, 2000, 5000, 10_000, 30_000, 60_000];
@@ -33,9 +34,10 @@ export function createNotificationService(api: any) {
   let retryCount = 0;
   let lastEventId: string | null = null;
   let running = false;
+  const cfg = () => getPluginConfig(api);
 
   function getApiKey(): string | undefined {
-    return api.config?.plugins?.entries?.twindex?.config?.apiKey;
+    return cfg().apiKey;
   }
 
   const logger = api.logger;
@@ -146,7 +148,7 @@ export function createNotificationService(api: any) {
   }
 
   return {
-    id: "twindex-notifications",
+    id: `${getPluginId(api)}-notifications`,
 
     start() {
       if (running) return;

package/src/config.ts

@@ -1,23 +0,0 @@
-import { existsSync, readFileSync } from "fs";
-import { homedir } from "os";
-import { join } from "path";
-
-type PluginConfig = Record<string, any>;
-
-export function readDiskPluginConfig(): PluginConfig {
-  try {
-    const configPath = join(homedir(), ".openclaw", "openclaw.json");
-    if (!existsSync(configPath)) return {};
-    const raw = readFileSync(configPath, "utf-8");
-    const parsed = JSON.parse(raw);
-    return parsed?.plugins?.entries?.twindex?.config ?? {};
-  } catch {
-    return {};
-  }
-}
-
-export function mergedPluginConfig(api: any): PluginConfig {
-  const disk = readDiskPluginConfig();
-  const memory = api.config?.plugins?.entries?.twindex?.config ?? {};
-  return { ...disk, ...memory };
-}