twindex-openclaw-plugin 0.8.20260410 → 0.8.20260412

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "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.20260410",
+  "version": "0.8.20260412",
   "skills": ["./skills"],
   "configSchema": {
     "type": "object",

package/package.json

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

package/src/index.ts

@@ -4,9 +4,12 @@ import { homedir } from "os";
 import * as twindex from "./client.js";
 import { createNotificationService } from "./poll-service.js";
 import {
+  claimBootstrapRegistration,
+  completeBootstrapRegistration,
   getPluginConfig,
   migrateLegacyPluginConfig,
   persistPluginConfig,
+  waitForBootstrapRegistration,
 } from "./plugin-config.js";
 
 let bootstrapping = false;
@@ -23,6 +26,31 @@ export default function register(api: any) {
     api.logger?.info?.("NewLore: config persisted to disk");
   }
 
+  async function ensureApiKey(): Promise<string> {
+    const current = cfg();
+    if (current.apiKey) return current.apiKey;
+
+    const claim = claimBootstrapRegistration(api);
+    if (!claim.claimed) {
+      const resolved = await waitForBootstrapRegistration(api);
+      if (resolved.apiKey) return resolved.apiKey;
+      throw new Error("registration already in progress");
+    }
+
+    try {
+      const agentId =
+        api.agentId ??
+        api.config?.agentId ??
+        `openclaw-${crypto.randomUUID()}`;
+      const reg = await twindex.register(agentId);
+      completeBootstrapRegistration(api, reg.api_key);
+      return reg.api_key;
+    } catch (err: any) {
+      completeBootstrapRegistration(api, undefined, err?.message ?? String(err));
+      throw err;
+    }
+  }
+
   // ── Poll-based notification service ──────────────────────────────
   const pollService = createNotificationService(api);
   api.registerService?.(pollService);
@@ -53,34 +81,64 @@ export default function register(api: any) {
     return "telegram";
   }
 
+  function isGatewayRuntime(): boolean {
+    const [command] = process.argv.slice(2);
+    return command === "gateway";
+  }
+
+  async function ensureArtistSubscriptions(
+    apiKey: string,
+    artists: string[],
+  ): Promise<string[]> {
+    let existing = new Set<string>();
+    try {
+      const subscriptions = await twindex.listSubscriptions(apiKey);
+      existing = new Set(subscriptions.map((subscription) => subscription.brand));
+    } catch (err: any) {
+      api.logger?.warn?.(
+        `NewLore: failed to list existing subscriptions: ${err.message}`,
+      );
+    }
+
+    const results: string[] = [];
+    for (const artist of artists) {
+      if (existing.has(artist)) {
+        api.logger?.info?.(`NewLore: already subscribed to ${artist}`);
+        results.push(`Already subscribed to ${artist}`);
+        continue;
+      }
+
+      try {
+        await twindex.subscribe(apiKey, artist);
+        api.logger?.info?.(`NewLore: auto-subscribed to ${artist}`);
+        results.push(`Subscribed to ${artist}`);
+      } catch (err: any) {
+        api.logger?.warn?.(
+          `NewLore: failed to subscribe to ${artist}: ${err.message}`,
+        );
+        results.push(`${artist}: ${err.message}`);
+      }
+    }
+
+    return results;
+  }
+
   // ── Auto-bootstrap: register + subscribe ────────────────────────
 
   (async () => {
+    if (!isGatewayRuntime()) {
+      api.logger?.info?.("NewLore: skipping auto-bootstrap outside gateway runtime");
+      return;
+    }
+
     if (bootstrapping) return;
     bootstrapping = true;
     try {
       const config = cfg();
       if (config.artists?.length > 0 && !config.apiKey) {
-        const agentId =
-          api.agentId ?? api.config?.agentId ?? `openclaw-${crypto.randomUUID()}`;
-        const reg = await twindex.register(agentId);
-        const apiKey = reg.api_key;
-
-        for (const artist of config.artists) {
-          try {
-            await twindex.subscribe(apiKey, artist);
-            api.logger?.info?.(`NewLore: auto-subscribed to ${artist}`);
-          } catch (err: any) {
-            api.logger?.warn?.(
-              `NewLore: failed to subscribe to ${artist}: ${err.message}`,
-            );
-          }
-        }
-
-        // Auto-detect chatTarget from channel config if not explicitly set
+        const frequency = config.frequency ?? "periodic";
         const updates: Record<string, any> = {
-          apiKey,
-          frequency: config.frequency ?? "periodic",
+          frequency,
         };
         const chatTarget = inferChatTarget();
         if (chatTarget) {
@@ -89,7 +147,12 @@ export default function register(api: any) {
           api.logger?.info?.(`NewLore: auto-detected chatTarget=${chatTarget}`);
         }
 
-        persistConfig(updates);
+        const apiKey = await ensureApiKey();
+        persistConfig({
+          apiKey,
+          ...updates,
+        });
+        await ensureArtistSubscriptions(apiKey, config.artists);
 
         // Set city if configured
         if (config.city) {
@@ -192,12 +255,7 @@ export default function register(api: any) {
         }
 
         if (!apiKey) {
-          const agentId =
-            api.agentId ??
-            api.config?.agentId ??
-            `openclaw-${crypto.randomUUID()}`;
-          const reg = await twindex.register(agentId);
-          apiKey = reg.api_key;
+          apiKey = await ensureApiKey();
         }
 
         persistConfig({
@@ -217,15 +275,7 @@ export default function register(api: any) {
           }
         }
 
-        const results: string[] = [];
-        for (const artist of params.artists) {
-          try {
-            await twindex.subscribe(apiKey, artist);
-            results.push(`Subscribed to ${artist}`);
-          } catch (err: any) {
-            results.push(`${artist}: ${err.message}`);
-          }
-        }
+        const results = await ensureArtistSubscriptions(apiKey, params.artists);
 
         pollService.start();
         results.push("Notification polling enabled");

package/src/plugin-config.ts

@@ -1,8 +1,9 @@
-import { readFileSync, writeFileSync } from "fs";
+import { closeSync, openSync, readFileSync, writeFileSync } from "fs";
 import { homedir } from "os";
 import { join } from "path";
 
 const LEGACY_PLUGIN_IDS = ["twindex"];
+const BOOTSTRAP_WINDOW_MS = 90_000;
 
 export type NewLorePluginConfig = {
   apiKey?: string;
@@ -13,6 +14,15 @@ export type NewLorePluginConfig = {
   city?: string;
 };
 
+type BootstrapState = {
+  status: "in_progress" | "complete" | "failed";
+  apiKey?: string;
+  owner?: string;
+  startedAt?: string;
+  updatedAt?: string;
+  error?: string;
+};
+
 function isRecord(value: unknown): value is Record<string, any> {
   return typeof value === "object" && value !== null;
 }
@@ -29,6 +39,63 @@ function resolveLegacyConfig(api: any): NewLorePluginConfig | undefined {
   return undefined;
 }
 
+function getConfigPath(): string {
+  return join(homedir(), ".openclaw", "openclaw.json");
+}
+
+function getBootstrapStatePath(pluginId: string): string {
+  return join(homedir(), ".openclaw", `${pluginId}-bootstrap.json`);
+}
+
+function readJSON(path: string): any | undefined {
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return undefined;
+  }
+}
+
+function readDiskPluginConfig(pluginId: string): NewLorePluginConfig | undefined {
+  const disk = readJSON(getConfigPath());
+  const currentConfig = disk?.plugins?.entries?.[pluginId]?.config;
+  if (isRecord(currentConfig) && Object.keys(currentConfig).length > 0) {
+    return currentConfig as NewLorePluginConfig;
+  }
+
+  for (const legacyPluginId of LEGACY_PLUGIN_IDS) {
+    const legacyConfig = disk?.plugins?.entries?.[legacyPluginId]?.config;
+    if (isRecord(legacyConfig) && Object.keys(legacyConfig).length > 0) {
+      return legacyConfig as NewLorePluginConfig;
+    }
+  }
+
+  return undefined;
+}
+
+function readBootstrapState(pluginId: string): BootstrapState | undefined {
+  const raw = readJSON(getBootstrapStatePath(pluginId));
+  if (!isRecord(raw)) return undefined;
+  if (raw.status !== "in_progress" && raw.status !== "complete" && raw.status !== "failed") {
+    return undefined;
+  }
+  return raw as BootstrapState;
+}
+
+function writeBootstrapState(pluginId: string, state: BootstrapState): void {
+  writeFileSync(
+    getBootstrapStatePath(pluginId),
+    JSON.stringify(state, null, 2) + "\n",
+    "utf-8",
+  );
+}
+
+function isFreshBootstrap(state?: BootstrapState): boolean {
+  if (!state || state.status !== "in_progress") return false;
+  const startedAt = Date.parse(state.updatedAt ?? state.startedAt ?? "");
+  if (Number.isNaN(startedAt)) return false;
+  return Date.now() - startedAt < BOOTSTRAP_WINDOW_MS;
+}
+
 function ensurePluginEntry(api: any, pluginId: string): Record<string, any> {
   if (!isRecord(api.config)) api.config = {};
   if (!isRecord(api.config.plugins)) api.config.plugins = {};
@@ -71,7 +138,7 @@ function persistConfigToDisk(
   pluginId: string,
   nextConfig?: NewLorePluginConfig,
 ): boolean {
-  const configPath = join(homedir(), ".openclaw", "openclaw.json");
+  const configPath = getConfigPath();
   const raw = readFileSync(configPath, "utf-8");
   const disk = JSON.parse(raw);
   let changed = false;
@@ -109,6 +176,19 @@ export function getPluginConfig(api: any): NewLorePluginConfig {
     return currentConfig as NewLorePluginConfig;
   }
 
+  const diskConfig = readDiskPluginConfig(pluginId);
+  if (diskConfig) {
+    api.pluginConfig = diskConfig;
+    return diskConfig;
+  }
+
+  const bootstrapState = readBootstrapState(pluginId);
+  if (bootstrapState?.apiKey) {
+    const bootstrapConfig = { apiKey: bootstrapState.apiKey };
+    api.pluginConfig = bootstrapConfig;
+    return bootstrapConfig;
+  }
+
   return resolveLegacyConfig(api) ?? {};
 }
 
@@ -157,3 +237,85 @@ export function migrateLegacyPluginConfig(api: any): boolean {
   persistPluginConfig(api, legacyConfig);
   return true;
 }
+
+export function claimBootstrapRegistration(api: any): {
+  claimed: boolean;
+  config: NewLorePluginConfig;
+} {
+  const pluginId = getPluginId(api);
+  const config = getPluginConfig(api);
+  if (config.apiKey) return { claimed: false, config };
+
+  const state = readBootstrapState(pluginId);
+  if (state?.apiKey) {
+    const nextConfig = persistPluginConfig(api, { apiKey: state.apiKey });
+    return { claimed: false, config: nextConfig };
+  }
+  if (isFreshBootstrap(state)) {
+    return { claimed: false, config };
+  }
+
+  const statePath = getBootstrapStatePath(pluginId);
+  try {
+    const fd = openSync(statePath, "wx");
+    closeSync(fd);
+  } catch (err: any) {
+    if (err?.code === "EEXIST") {
+      const existing = readBootstrapState(pluginId);
+      if (existing?.apiKey) {
+        const nextConfig = persistPluginConfig(api, { apiKey: existing.apiKey });
+        return { claimed: false, config: nextConfig };
+      }
+      if (isFreshBootstrap(existing)) {
+        return { claimed: false, config };
+      }
+    } else {
+      throw err;
+    }
+  }
+
+  writeBootstrapState(pluginId, {
+    status: "in_progress",
+    owner: `${process.pid}:${Date.now()}`,
+    startedAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+  });
+
+  return { claimed: true, config };
+}
+
+export function completeBootstrapRegistration(
+  api: any,
+  apiKey?: string,
+  error?: string,
+): void {
+  const pluginId = getPluginId(api);
+  writeBootstrapState(pluginId, {
+    status: apiKey ? "complete" : "failed",
+    apiKey,
+    error,
+    updatedAt: new Date().toISOString(),
+  });
+}
+
+export async function waitForBootstrapRegistration(
+  api: any,
+  timeoutMs = 20_000,
+): Promise<NewLorePluginConfig> {
+  const pluginId = getPluginId(api);
+  const deadline = Date.now() + timeoutMs;
+
+  while (Date.now() < deadline) {
+    const config = getPluginConfig(api);
+    if (config.apiKey) return config;
+
+    const state = readBootstrapState(pluginId);
+    if (state?.apiKey) {
+      return persistPluginConfig(api, { apiKey: state.apiKey });
+    }
+
+    await new Promise((resolve) => setTimeout(resolve, 250));
+  }
+
+  return getPluginConfig(api);
+}