bereach-openclaw 1.5.5 → 1.5.6

package/README.md

@@ -21,8 +21,11 @@ openclaw plugins install bereach-openclaw
 **Before upgrading:** note your `BEREACH_API_KEY` - uninstall may remove `plugins.entries.bereach-openclaw`.
 
 ```bash
-# 1. Uninstall
+# 1. Uninstall + fully delete (rm prevents stale .old copies causing 401 loops)
 openclaw plugins uninstall bereach-openclaw
+rm -rf /data/.openclaw/extensions/bereach-openclaw*
+rm -rf /data/.openclaw/node_modules/bereach-openclaw
+rm -rf /data/.openclaw/node_modules/bereach
 
 # 2. Reinstall latest
 openclaw plugins install bereach-openclaw
@@ -108,9 +111,9 @@ OpenClaw loads plugins from **two locations**:
 
 If `extensions/bereach-openclaw/` is corrupt or incomplete, you get trim/undefined errors. Fix:
 
-**1. Backup and remove the active extension:**
+**1. Fully remove the active extension** (do NOT rename to `.bak` - OpenClaw loads `.bak`/`.old` copies as duplicate plugins):
 ```bash
-mv /data/.openclaw/extensions/bereach-openclaw /data/.openclaw/extensions/bereach-openclaw.bak.$(date +%s)
+rm -rf /data/.openclaw/extensions/bereach-openclaw*
 ```
 
 **2. Reinstall from npm (inside the container):**

package/node_modules/@bereach/tools/src/definitions.ts

@@ -1428,6 +1428,7 @@ export const definitions: ToolDefinition[] = [
         lifecycleStage: { type: "string", enum: ["contact", "lead", "qualified", "approved", "rejected"], description: "New stage (forward-only, or rejected)." },
         hotScore: { type: "integer", minimum: 0, maximum: 100 },
         qualificationNotes: { type: "string", description: "Agent reasoning for qualification/rejection." },
+        leadBrief: { type: "string", description: "2-3 sentence human-readable lead summary for sales prep. NOT ICP analysis — a cheat sheet: who this person is, what they care about, notable background, conversation hooks." },
         notes: { type: "string" },
         name: { type: "string", description: "Update contact name." },
         profileData: { type: "object", description: "Full LinkedIn profile snapshot (JSON)." },

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "bereach-openclaw",
   "name": "BeReach",
-  "version": "1.5.5",
+  "version": "1.5.6",
   "description": "LinkedIn outreach automation — 75+ tools, hook-based enforcement, dynamic context",
   "configSchema": {
     "type": "object",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bereach-openclaw",
-  "version": "1.5.5",
+  "version": "1.5.6",
   "description": "BeReach LinkedIn automation plugin for OpenClaw",
   "license": "AGPL-3.0",
   "exports": {

package/src/commands/connector.ts

@@ -58,6 +58,7 @@ type TaskResult = {
   commentsPosted?: number;
   invitationsAccepted?: number;
   error?: string;
+  reason?: string;
 };
 
 const MIN_POLL_MS = 5000;
@@ -230,13 +231,12 @@ async function isWebhookAvailable(config: ConnectorConfig): Promise<boolean> {
     if (res.status === 401 || res.status === 403) return false;
     if (res.ok || res.status === 405 || res.status === 204) return true;
 
-    // Some gateways don't support OPTIONS - fall back to GET on root
-    const rootRes = await fetch(config.gatewayUrl, {
-      method: "GET",
-      signal: AbortSignal.timeout(3000),
-    });
-    // Gateway is up - assume hooks are available if we have a token
-    return rootRes.ok || rootRes.status === 404;
+    // OPTIONS returned non-2xx/405 (e.g. 404): /hooks/agent doesn't exist.
+    // Don't assume hooks are available just because the gateway root responds.
+    // This prevents a false-positive where the connector keeps dispatching
+    // to a webhook URL that doesn't exist, failing every task with 404.
+    console.log(`[connector] Webhook probe: OPTIONS /hooks/agent returned ${res.status}, hooks not available`);
+    return false;
   } catch {
     return false;
   }
@@ -480,9 +480,18 @@ async function executeOnOpenClaw(
   config: ConnectorConfig,
   task: NonNullable<PullResponse["task"]>,
   webhookAvailable: boolean,
-): Promise<{ result: TaskResult | null; error: string | null }> {
+): Promise<{ result: TaskResult | null; error: string | null; webhookDead?: boolean }> {
   if (webhookAvailable) {
-    return executeViaWebhook(config, task);
+    const res = await executeViaWebhook(config, task);
+    // Detect webhook 404 — hooks endpoint doesn't exist (plugin version mismatch,
+    // gateway restart needed). Fall back to execFile for this task AND signal the
+    // main loop to flip webhookAvailable so subsequent tasks don't keep failing.
+    if (res.error?.startsWith("Webhook HTTP 404")) {
+      console.warn(`[connector] Webhook returned 404, falling back to execFile for task ${task.id}`);
+      const fallback = await executeViaExecFile(task);
+      return { ...fallback, webhookDead: true };
+    }
+    return res;
   }
   console.log(`[connector] Webhook unavailable, falling back to execFile`);
   return executeViaExecFile(task);
@@ -612,6 +621,7 @@ export async function runConnectorLoop(
         );
 
         try {
+          (task as any)._startedAt = Date.now();
           await updateTaskStatus(config, task.id, "accepted");
           await updateTaskStatus(config, task.id, "running");
 
@@ -625,9 +635,9 @@ export async function runConnectorLoop(
           }, watchdogMs);
           watchdogTimer.unref(); // Don't prevent graceful shutdown
 
-          const { result, error } = await Promise.race([
+          const execResult = await Promise.race([
             executeOnOpenClaw(config, task, webhookAvailable),
-            new Promise<{ result: null; error: string }>((resolve) => {
+            new Promise<{ result: null; error: string; webhookDead?: boolean }>((resolve) => {
               const check = setTimeout(() => {
                 if (watchdogFired) {
                   resolve({ result: null, error: `Watchdog: task execution exceeded ${Math.round(watchdogMs / 1000)}s timeout` });
@@ -636,21 +646,36 @@ export async function runConnectorLoop(
               check.unref();
             }),
           ]);
+          const { result, error } = execResult;
+          // If webhook returned 404, disable it for future tasks
+          if (execResult.webhookDead) {
+            console.warn(`[connector] Disabling webhook mode — /hooks/agent not available`);
+            webhookAvailable = false;
+          }
           clearTimeout(watchdogTimer);
 
           const taskStatus = error ? "failed" : (result?.success !== false ? "succeeded" : "failed");
+          const execDuration = Date.now() - (task as any)._startedAt;
           console.log(
-            `[connector] Task ${task.id} ${taskStatus}${error ? `: ${error.slice(0, 100)}` : ""}${task.workflowRunId ? ` workflow=${task.workflowRunId}` : ""}`,
+            `[connector] Task ${task.id} ${taskStatus} (${Math.round(execDuration / 1000)}s)${error ? `: ${error.slice(0, 100)}` : ""}${result?.reason ? ` reason=${result.reason}` : ""}${task.workflowRunId ? ` workflow=${task.workflowRunId}` : ""}`,
           );
-
-          // With webhook execution, the lifecycle hook auto-reports results.
-          // Submit from connector for execFile fallback, errors, or as safety net
-          // when lifecycle hook may not have fired (agent crash).
-          // Don't submit if result looks successful — lifecycle hook already posted.
-          if (!webhookAvailable || error) {
-            await submitResult(config, task.id, result, error);
+          // Flag suspicious fast failures with no tools for investigation
+          if (!error && result?.success === false && (result as any)?.toolCallCount === 0 && execDuration < 10_000) {
+            console.warn(`[connector] DIAGNOSTIC: Task ${task.id} failed in <10s with 0 tool calls — likely context injection failure or model error`);
           }
 
+          // Always submit from connector as safety net. In webhook mode the lifecycle
+          // hook usually reports first, but if it fails silently (network, crash) the
+          // result is lost and the task stays "running" forever. The result endpoint
+          // uses an optimistic lock so double-submissions are harmless (second is a no-op).
+          // Derive error when result indicates failure but no explicit error exists.
+          const derivedError = error ?? (
+            result?.success === false
+              ? (result.error ?? result.reason ?? "Task failed (no details from agent)")
+              : undefined
+          );
+          await submitResult(config, task.id, result, derivedError ?? null);
+
           totalTasksExecuted++;
           pollInterval = 5_000;
         } finally {

package/src/hooks/lifecycle.ts

@@ -125,9 +125,25 @@ export function registerLifecycleHook(
           creditsUsed: state.creditsUsedThisSession,
           toolCallCount: state.toolCallCount,
           visitCount: state.visitCount,
-          ...(state.toolCallCount === 0 ? { reason: "no_tools_called" } : {}),
+          ...(state.toolCallCount === 0 ? { reason: "no_tools_called", error: "Task completed with no tool calls" } : {}),
         };
 
+        // Diagnostic logging for no_tools_called — capture WHY the agent did nothing.
+        // This helps diagnose context injection failures, model errors, etc.
+        if (state.toolCallCount === 0) {
+          const msgCount = allMessages.length;
+          const userMsgCount = userMsgs.length;
+          const assistantMsgCount = assistantMsgs.length;
+          const lastAssistantText = outputText?.slice(0, 300) || "(empty)";
+          const hasTaskMeta = userMsgs.some((m: any) => extractTextFromContent(m.content).includes("TASK_META"));
+          const endSuccess = (endCtx as any)?.success;
+          const endError = (endCtx as any)?.error;
+          log(`NO_TOOLS_CALLED diagnostic for ${taskMode.taskId}: ` +
+            `msgs=${msgCount} (user=${userMsgCount} assistant=${assistantMsgCount}) ` +
+            `hasTaskMeta=${hasTaskMeta} endSuccess=${endSuccess} endError=${endError ? String(endError).slice(0, 200) : "none"} ` +
+            `lastAssistant="${lastAssistantText}"`);
+        }
+
         // B17 fix: In execFile mode, the connector also submits results after
         // parsing the OpenClaw --json wrapper (extractTaskResultFromWrapper).
         // The lifecycle hook fires first (inside subprocess), so it wins the race.
@@ -148,10 +164,14 @@ export function registerLifecycleHook(
           attempts++;
           try {
             if (attempt > 0) await new Promise((r) => setTimeout(r, 2000 * attempt));
+            // Derive error from result when task failed but no explicit error exists
+            const taskError = taskResult.success === false
+              ? (taskResult.error ?? taskResult.reason ?? "Task failed (no details captured)")
+              : undefined;
             const res = await fetch(`${API_BASE}/tasks/${taskMode.taskId}/result`, {
               method: "POST",
               headers: { Authorization: `Bearer ${key}`, "Content-Type": "application/json" },
-              body: JSON.stringify({ result: taskResult }),
+              body: JSON.stringify({ result: taskResult, ...(taskError ? { error: taskError } : {}) }),
               signal: AbortSignal.timeout(10000),
             });
             if (res.ok) {

package/src/index.ts

@@ -18,6 +18,9 @@ const log = createLogger("init");
 const registeredApis = new WeakSet<object>();
 let registeredCount = 0;
 let autoDetectDone = false;
+let lastRegisterAt = 0;
+/** After initial burst, suppress noisy re-registration logs */
+const REGISTER_LOG_THRESHOLD = 5;
 
 /**
  * Resolve the BeReach API key from all supported sources (in priority order):
@@ -120,8 +123,11 @@ export default function register(api: any) {
   }
 
   registeredCount++;
-  if (registeredCount > 1) {
+  lastRegisterAt = Date.now();
+  if (registeredCount > 1 && registeredCount <= REGISTER_LOG_THRESHOLD) {
     log(`register() called again (call #${registeredCount}) — re-registering on new api instance`);
+  } else if (registeredCount === REGISTER_LOG_THRESHOLD + 1) {
+    log(`register() call #${registeredCount} — suppressing further re-registration logs`);
   }
   if (api && typeof api === "object") {
     registeredApis.add(api);