@karmaniverous/jeeves-watcher-openclaw 0.5.4 → 0.5.6

package/dist/cli.js

@@ -199,10 +199,62 @@ function uninstall() {
             writeJson(configPath, config);
         }
     }
+    // Clean up TOOLS.md watcher section
+    cleanupToolsMd(home, configPath);
     console.log();
     console.log('✅ Plugin uninstalled successfully.');
     console.log('   Restart the OpenClaw gateway to complete removal.');
 }
+/** Resolve the workspace directory from OpenClaw config. */
+function resolveWorkspaceDir(home, configPath) {
+    const config = readJson(configPath);
+    if (!config)
+        return null;
+    // Check agents.defaults.workspace
+    const agents = config.agents;
+    const defaults = agents?.defaults;
+    const workspace = defaults?.workspace;
+    if (workspace) {
+        return resolve(workspace.replace(/^~/, homedir()));
+    }
+    // Default workspace location
+    return join(home, 'workspace');
+}
+/** Remove the ## Watcher section from TOOLS.md on uninstall. */
+function cleanupToolsMd(home, configPath) {
+    const workspaceDir = resolveWorkspaceDir(home, configPath);
+    if (!workspaceDir)
+        return;
+    const toolsPath = join(workspaceDir, 'TOOLS.md');
+    if (!existsSync(toolsPath))
+        return;
+    let content = readFileSync(toolsPath, 'utf8');
+    // Remove ## Watcher section (from ## Watcher to next ## or # or EOF)
+    const watcherRe = /^## Watcher\n[\s\S]*?(?=\n## |\n# |$(?![\s\S]))/m;
+    if (!watcherRe.test(content))
+        return;
+    content = content.replace(watcherRe, '').replace(/\n{3,}/g, '\n\n');
+    // If # Jeeves Platform Tools has no remaining ## sections, remove it too
+    const platformH1 = '# Jeeves Platform Tools';
+    if (content.includes(platformH1)) {
+        const h1Idx = content.indexOf(platformH1);
+        const afterH1 = content.slice(h1Idx + platformH1.length);
+        // Check if there's a ## before the next # or EOF
+        const nextH2Match = afterH1.match(/^## /m);
+        const nextH1Match = afterH1.match(/^# /m);
+        const h2Pos = nextH2Match ? afterH1.indexOf(nextH2Match[0]) : Infinity;
+        const h1Pos = nextH1Match ? afterH1.indexOf(nextH1Match[0]) : Infinity;
+        if (h2Pos >= h1Pos) {
+            // No child ## sections remain — remove the empty H1
+            content =
+                content.slice(0, h1Idx) + content.slice(h1Idx + platformH1.length);
+            content = content.replace(/^\n{2,}/, '').replace(/\n{3,}/g, '\n\n');
+        }
+    }
+    content = content.trim() + '\n';
+    writeFileSync(toolsPath, content);
+    console.log('\u2713 Cleaned up TOOLS.md (removed Watcher section)');
+}
 // Main
 const command = process.argv[2];
 switch (command) {

package/dist/index.js

@@ -1,9 +1,11 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+
 /**
  * @module plugin/helpers
  * Shared types and utility functions for the OpenClaw plugin tool registrations.
  */
 const DEFAULT_API_URL = 'http://127.0.0.1:1936';
-const DEFAULT_CACHE_TTL_MS = 30000;
 /** Extract plugin config from the API object */
 function getPluginConfig(api) {
     return api.config?.plugins?.entries?.['jeeves-watcher-openclaw']?.config;
@@ -13,11 +15,6 @@ function getApiUrl(api) {
     const url = getPluginConfig(api)?.apiUrl;
     return typeof url === 'string' ? url : DEFAULT_API_URL;
 }
-/** Resolve the cache TTL for plugin hooks from config. */
-function getCacheTtlMs(api) {
-    const ttl = getPluginConfig(api)?.cacheTtlMs;
-    return typeof ttl === 'number' ? ttl : DEFAULT_CACHE_TTL_MS;
-}
 /** Format a successful tool result. */
 function ok(data) {
     return {
@@ -73,14 +70,6 @@ async function postJson(url, body) {
     });
 }
 
-let menuCache = null;
-function isAgentBootstrapEventContext(value) {
-    if (!value || typeof value !== 'object') {
-        return false;
-    }
-    const v = value;
-    return Array.isArray(v.bootstrapFiles);
-}
 async function fetchJson(url, init) {
     const res = await fetch(url, init);
     if (!res.ok) {
@@ -177,68 +166,106 @@ async function generateWatcherMenu(apiUrl) {
     }
     return lines.join('\n');
 }
-async function getCachedWatcherMenu(apiUrl, ttlMs) {
-    const now = Date.now();
-    if (menuCache && menuCache.expiresAt > now) {
-        return menuCache.value;
-    }
-    const menu = await generateWatcherMenu(apiUrl);
-    menuCache = { value: menu, expiresAt: now + ttlMs };
-    return menu;
-}
-function ensurePlatformToolsSection(toolsMd) {
-    if (toolsMd.includes('# Jeeves Platform Tools')) {
-        return toolsMd;
+
+/**
+ * @module plugin/toolsWriter
+ * Writes the Watcher menu section directly to TOOLS.md on disk.
+ * Replaces the agent:bootstrap hook approach which was unreliable due to
+ * OpenClaw's clearInternalHooks() wiping plugin-registered hooks on startup.
+ */
+const REFRESH_INTERVAL_MS = 60_000;
+let intervalHandle = null;
+let lastWrittenMenu = '';
+/**
+ * Resolve the workspace TOOLS.md path.
+ * Uses api.resolvePath if available, otherwise falls back to CWD.
+ */
+function resolveToolsPath(api) {
+    const resolvePath = api
+        .resolvePath;
+    if (typeof resolvePath === 'function') {
+        return resolvePath('TOOLS.md');
     }
-    return `# Jeeves Platform Tools\n\n${toolsMd}`;
+    return resolve(process.cwd(), 'TOOLS.md');
 }
-function upsertWatcherSection(toolsMd, watcherMenu) {
-    const section = `## Watcher\n\n${watcherMenu}\n`;
-    // If we already injected a Watcher section, replace it.
-    // The `m` flag is needed so `^` matches line starts, but it also makes
-    // `$` match end-of-line instead of end-of-string.  Use a negative
-    // lookahead `$(?![\s\S])` to anchor at true end-of-string.
+/**
+ * Upsert the watcher section in TOOLS.md content.
+ *
+ * Strategy:
+ * - If a `## Watcher` section already exists, replace it in place.
+ * - Otherwise, prepend `# Jeeves Platform Tools\n\n## Watcher\n\n...`
+ *   before any existing content.
+ */
+function upsertWatcherContent(existing, watcherMenu) {
+    const section = `## Watcher\n\n${watcherMenu}`;
+    // Replace existing watcher section (match from ## Watcher to next ## or # or EOF)
     const re = /^## Watcher\n[\s\S]*?(?=\n## |\n# |$(?![\s\S]))/m;
-    if (re.test(toolsMd)) {
-        return toolsMd.replace(re, section);
+    if (re.test(existing)) {
+        return existing.replace(re, section);
     }
-    // Otherwise insert immediately after the H1 if present, else append.
-    const h1 = '# Jeeves Platform Tools';
-    const idx = toolsMd.indexOf(h1);
-    if (idx !== -1) {
-        const afterH1 = idx + h1.length;
-        return (toolsMd.slice(0, afterH1) + `\n\n${section}` + toolsMd.slice(afterH1));
+    // No existing section. Prepend under a platform tools H1.
+    const platformH1 = '# Jeeves Platform Tools';
+    if (existing.includes(platformH1)) {
+        // Insert after the H1
+        const idx = existing.indexOf(platformH1) + platformH1.length;
+        return existing.slice(0, idx) + `\n\n${section}\n` + existing.slice(idx);
     }
-    return `${toolsMd}\n\n${section}`;
+    // Prepend platform header + watcher section before existing content
+    const trimmed = existing.trim();
+    if (trimmed.length === 0) {
+        return `${platformH1}\n\n${section}\n`;
+    }
+    return `${platformH1}\n\n${section}\n\n${trimmed}\n`;
 }
 /**
- * Hook handler for agent:bootstrap.
- * Injects/updates the Watcher Menu into the TOOLS.md payload.
+ * Fetch the current watcher menu and write it to TOOLS.md if changed.
+ * Returns true if the file was updated.
  */
-async function handleAgentBootstrap(event, api) {
-    const context = event?.context;
-    if (!isAgentBootstrapEventContext(context)) {
-        return;
-    }
+async function refreshToolsMd(api) {
     const apiUrl = getApiUrl(api);
-    const cacheTtlMs = getCacheTtlMs(api);
-    const watcherMenu = await getCachedWatcherMenu(apiUrl, cacheTtlMs);
-    let toolsFile = context.bootstrapFiles.find((f) => f.name === 'TOOLS.md');
-    if (!toolsFile) {
-        toolsFile = { name: 'TOOLS.md', content: '', missing: false };
-        context.bootstrapFiles.push(toolsFile);
+    const menu = await generateWatcherMenu(apiUrl);
+    if (menu === lastWrittenMenu) {
+        return false;
+    }
+    const toolsPath = resolveToolsPath(api);
+    let current = '';
+    try {
+        current = await readFile(toolsPath, 'utf8');
+    }
+    catch {
+        // File doesn't exist yet — we'll create it
     }
-    const current = toolsFile.content ?? '';
-    // Guard: the bootstrap hook fires on every message turn because OpenClaw
-    // caches bootstrapFiles per session and returns the same mutable objects.
-    // If we already injected the watcher menu into this content, skip to
-    // avoid accumulating duplicate sections.
-    if (current.includes('## Watcher') && current.includes(watcherMenu)) {
-        return;
+    const updated = upsertWatcherContent(current, menu);
+    if (updated !== current) {
+        await writeFile(toolsPath, updated, 'utf8');
+        lastWrittenMenu = menu;
+        return true;
+    }
+    lastWrittenMenu = menu;
+    return false;
+}
+/**
+ * Start the periodic TOOLS.md writer.
+ * Writes immediately on startup, then refreshes every REFRESH_INTERVAL_MS.
+ */
+function startToolsWriter(api) {
+    // Initial write (fire and forget — errors logged but not thrown)
+    refreshToolsMd(api).catch((err) => {
+        console.error('[jeeves-watcher] Failed to write TOOLS.md:', err);
+    });
+    // Periodic refresh
+    if (intervalHandle) {
+        clearInterval(intervalHandle);
+    }
+    intervalHandle = setInterval(() => {
+        refreshToolsMd(api).catch((err) => {
+            console.error('[jeeves-watcher] Failed to refresh TOOLS.md:', err);
+        });
+    }, REFRESH_INTERVAL_MS);
+    // Don't keep the process alive just for this interval
+    if (typeof intervalHandle === 'object' && 'unref' in intervalHandle) {
+        intervalHandle.unref();
     }
-    const withH1 = ensurePlatformToolsSection(current);
-    const updated = upsertWatcherSection(withH1, watcherMenu);
-    toolsFile.content = updated;
 }
 
 /**
@@ -427,13 +454,11 @@ function registerWatcherTools(api, baseUrl) {
 function register(api) {
     const baseUrl = getApiUrl(api);
     registerWatcherTools(api, baseUrl);
-    // Register the agent:bootstrap hook if the host OpenClaw version supports it
-    const registerHook = api.registerHook;
-    if (typeof registerHook === 'function') {
-        registerHook('agent:bootstrap', async (event) => {
-            await handleAgentBootstrap(event, api);
-        }, { name: 'jeeves-watcher-openclaw' });
-    }
+    // Write the watcher menu to TOOLS.md on disk, refreshing periodically.
+    // This replaces the agent:bootstrap hook approach which was unreliable
+    // because OpenClaw's clearInternalHooks() wipes plugin-registered hooks
+    // during the async startup sequence.
+    startToolsWriter(api);
 }
 
 export { register as default };

package/dist/src/promptInjection.d.ts

@@ -1,4 +1,9 @@
 import { type PluginApi } from './helpers.js';
+/**
+ * Fetches data from the watcher API and generates a Markdown menu string.
+ * The string is platform-agnostic and safe to inject into TOOLS.md.
+ */
+export declare function generateWatcherMenu(apiUrl: string): Promise<string>;
 /**
  * Hook handler for agent:bootstrap.
  * Injects/updates the Watcher Menu into the TOOLS.md payload.

package/dist/src/toolsWriter.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @module plugin/toolsWriter
+ * Writes the Watcher menu section directly to TOOLS.md on disk.
+ * Replaces the agent:bootstrap hook approach which was unreliable due to
+ * OpenClaw's clearInternalHooks() wiping plugin-registered hooks on startup.
+ */
+import { type PluginApi } from './helpers.js';
+/**
+ * Start the periodic TOOLS.md writer.
+ * Writes immediately on startup, then refreshes every REFRESH_INTERVAL_MS.
+ */
+export declare function startToolsWriter(api: PluginApi): void;
+/**
+ * Force an immediate refresh (e.g., after watcher_config_apply).
+ */
+export declare function forceRefreshToolsMd(api: PluginApi): Promise<void>;
+/**
+ * Stop the periodic writer (for cleanup).
+ */
+export declare function stopToolsWriter(): void;

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "jeeves-watcher-openclaw",
   "name": "Jeeves Watcher",
   "description": "Semantic search, metadata enrichment, and instance administration for a jeeves-watcher deployment.",
-  "version": "0.5.4",
+  "version": "0.5.6",
   "skills": [
     "dist/skills/jeeves-watcher"
   ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@karmaniverous/jeeves-watcher-openclaw",
-  "version": "0.5.4",
+  "version": "0.5.6",
   "author": "Jason Williscroft",
   "description": "OpenClaw plugin for jeeves-watcher — semantic search and metadata enrichment tools",
   "license": "BSD-3-Clause",