twindex-openclaw-plugin 0.8.20260411 → 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.20260411",
+  "version": "0.8.20260412",
   "skills": ["./skills"],
   "configSchema": {
     "type": "object",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "twindex-openclaw-plugin",
-  "version": "0.8.20260411",
+  "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);
@@ -119,10 +147,7 @@ export default function register(api: any) {
           api.logger?.info?.(`NewLore: auto-detected chatTarget=${chatTarget}`);
         }
 
-        const agentId =
-          api.agentId ?? api.config?.agentId ?? `openclaw-${crypto.randomUUID()}`;
-        const reg = await twindex.register(agentId);
-        const apiKey = reg.api_key;
+        const apiKey = await ensureApiKey();
         persistConfig({
           apiKey,
           ...updates,
@@ -230,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({

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);
+}