ofiere-openclaw-plugin 4.54.2 → 4.55.0

package/dist/src/tools.js

@@ -7214,6 +7214,117 @@ function registerBrainExtractionHook(api, supabase, userId, fallbackAgentId) {
                     // not the chief's. The chief gets a single L4 report entry above.
                     return;
                 }
+                // FIX-A2A-LATE-REPLY — direct chief↔chief A2A late reply.
+                // Dashboard's relayToOpenClaw caps the synchronous wait at 45s; when
+                // the responding chief takes longer (e.g. while running its own tool
+                // calls), the dashboard WS closes and the eventual reply is dropped.
+                // dispatch_context was pre-written with { conversation_id,
+                // source_agent_id, a2a_pair_id } so we can route the late reply back:
+                //   1. Insert the assistant turn into conversation_messages for the
+                //      A2A conversation so reloading the page shows the reply.
+                //   2. POST a `chief_reply` webhook so the dashboard SSE can swap the
+                //      "still processing" placeholder bubble in the active chat UI.
+                // Guarded by: a2a_pair_id is set AND subagent_id is null AND task_id
+                // is null — so neither the staff nor the scheduled branches above
+                // can collide with this path.
+                const a2aPairId = dispatchCtxRow?.a2a_pair_id ?? null;
+                const a2aSourceAgentId = dispatchCtxRow?.source_agent_id ?? null;
+                const a2aConversationId = dispatchCtxRow?.conversation_id ?? null;
+                if (a2aPairId &&
+                    !staffDispatchSubagentId &&
+                    !dispatchTaskIdFromCtx &&
+                    a2aConversationId) {
+                    (async () => {
+                        try {
+                            const excerpt = lastAssistant.slice(0, 4000);
+                            if (!excerpt) {
+                                api.logger.warn?.(`[ofiere-a2a-reply] empty assistant text — skipping late-reply persistence`);
+                                return;
+                            }
+                            // Insert assistant turn into the A2A conversation. The
+                            // dashboard's synchronous path also writes the assistant row
+                            // when the reply lands in-window — UI dedup is by content +
+                            // a2a_conversation_id so a duplicate from a race is benign.
+                            try {
+                                await supabase.from("conversation_messages").insert({
+                                    conversation_id: a2aConversationId,
+                                    user_id: userId,
+                                    role: "assistant",
+                                    content: excerpt,
+                                    metadata: {
+                                        sender_agent_id: resolvedAgentId,
+                                        target_agent_id: a2aSourceAgentId,
+                                        late_reply: true,
+                                    },
+                                    branch_id: "main",
+                                });
+                                await supabase.from("conversations")
+                                    .update({ updated_at: new Date().toISOString() })
+                                    .eq("id", a2aConversationId)
+                                    .eq("user_id", userId);
+                                // Best-effort message-count bump. RPC may not exist on older
+                                // schemas — swallow the error if it 404s.
+                                try {
+                                    await supabase.rpc("increment_conversation_message_count", {
+                                        conv_id: a2aConversationId,
+                                    });
+                                }
+                                catch { /* RPC missing — count drift is acceptable */ }
+                            }
+                            catch (cmErr) {
+                                api.logger.warn?.(`[ofiere-a2a-reply] conversation_messages insert failed: ${cmErr instanceof Error ? cmErr.message : String(cmErr)}`);
+                            }
+                            // Resolve responder agent name for the webhook payload so the
+                            // UI bubble can be attributed correctly without another DB hit.
+                            let responderName = null;
+                            try {
+                                const { data: agentRow } = await supabase
+                                    .from("agents")
+                                    .select("name")
+                                    .eq("id", resolvedAgentId)
+                                    .eq("user_id", userId)
+                                    .maybeSingle();
+                                responderName = agentRow?.name ?? null;
+                            }
+                            catch { /* fall back to agent id */ }
+                            const webhookUrl = process.env.OFIERE_DASHBOARD_WEBHOOK_URL || "";
+                            const webhookSecret = process.env.OPENCLAW_WEBHOOK_SECRET || "";
+                            if (webhookUrl && webhookSecret) {
+                                try {
+                                    await fetch(webhookUrl, {
+                                        method: "POST",
+                                        headers: {
+                                            "content-type": "application/json",
+                                            authorization: `Bearer ${webhookSecret}`,
+                                        },
+                                        body: JSON.stringify({
+                                            type: "chief_reply",
+                                            payload: {
+                                                user_id: userId,
+                                                source_agent_id: a2aSourceAgentId,
+                                                target_agent_id: resolvedAgentId,
+                                                target_agent_name: responderName,
+                                                conversation_id: a2aConversationId,
+                                                a2a_pair_id: a2aPairId,
+                                                response: excerpt,
+                                            },
+                                        }),
+                                    });
+                                    api.logger.info?.(`[ofiere-a2a-reply] chief_reply webhook posted (conv=${a2aConversationId})`);
+                                }
+                                catch (wErr) {
+                                    api.logger.debug?.(`[ofiere-a2a-reply] webhook post failed: ${wErr instanceof Error ? wErr.message : String(wErr)}`);
+                                }
+                            }
+                        }
+                        catch (aErr) {
+                            api.logger.warn?.(`[ofiere-a2a-reply] failed: ${aErr instanceof Error ? aErr.message : String(aErr)}`);
+                        }
+                    })();
+                    // Continue to brain extraction below — A2A late-reply is purely
+                    // additive bookkeeping; the responding chief still owns the L1/L2
+                    // memory writes for its own turn.
+                }
                 // BUG 9 fix (BUGSHOOT-2): mark task_dispatch_log row complete for
                 // non-staff scheduled dispatches too. Without this the log row stays
                 // at 'dispatched' even after the chief finished the run.

package/index.ts

@@ -1,105 +1,105 @@
-// index.ts — Ofiere PM Plugin for OpenClaw
-// Matches Composio plugin pattern: plain object export + api.on()
-
-import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
-import { parseOfiereConfig } from "./src/config.js";
-import { getSupabase } from "./src/supabase.js";
-import { registerTools, probeApiForAgentName } from "./src/tools.js";
-import { getSystemPrompt } from "./src/prompt.js";
-import { registerCli } from "./src/cli.js";
-import { seedAgentCache } from "./src/agent-resolver.js";
-
-const ofierePlugin = {
-  id: "ofiere",
-  name: "Ofiere PM",
-  description:
-    "Manage Ofiere PM tasks, agents, and projects directly from the agent. " +
-    "Create tasks, update progress, assign agents — all synced to the dashboard in real time.",
-
-  register(api: OpenClawPluginApi) {
-    const config = parseOfiereConfig(api.pluginConfig);
-
-    // Always register CLI (even if disabled — so user can run `openclaw ofiere setup`)
-    registerCli(api);
-
-    if (!config.enabled) {
-      api.logger.debug?.("[ofiere] Plugin disabled via config");
-      return;
-    }
-
-    if (!config.supabaseUrl || !config.serviceRoleKey) {
-      api.logger.warn(
-        "[ofiere] Not configured. Run: openclaw ofiere setup",
-      );
-      return;
-    }
-
-    if (!config.userId) {
-      api.logger.warn(
-        "[ofiere] Missing userId. Run: openclaw ofiere setup",
-      );
-      return;
-    }
-
-    // ── Pre-seed agent cache if OFIERE_AGENT_ID is set (legacy mode) ──────
-    if (config.agentId) {
-      const callerName =
-        (api as any)?.agentContext?.accountId ||
-        (api as any)?.agentContext?.name ||
-        (api as any)?.currentAgent?.accountId ||
-        "";
-      if (callerName) {
-        seedAgentCache(callerName, config.userId, config.agentId);
-      }
-    }
-
-    // ── State for system prompt injection ──────────────────────────────────
-    const promptState = {
-      toolCount: 0,
-      agentId: config.agentId,
-      connectError: "",
-      ready: false,
-    };
-
-    // ── System prompt is built ONCE (it's static after init) ──────────────
-    // No hook needed here — the brain context hook in tools.ts uses
-    // prependSystemContext via getSystemPromptCached() to combine both
-    // in a single hook invocation, eliminating one serial hook call.
-    let cachedSystemPrompt = "";
-    const getSystemPromptCached = () => {
-      if (!cachedSystemPrompt) {
-        cachedSystemPrompt = getSystemPrompt(promptState);
-      }
-      return cachedSystemPrompt;
-    };
-
-    // Hook: inject BOTH system prompt + brain context in one call
-    api.on("before_prompt_build", () => ({
-      prependSystemContext: getSystemPromptCached(),
-    }));
-
-    // ── Connect to Supabase and register tools ────────────────────────────
-    try {
-      const supabase = getSupabase(config.supabaseUrl, config.serviceRoleKey);
-
-      // Probe the api object for any agent identity info (for debugging + fallback)
-      probeApiForAgentName(api, api.logger);
-
-      // registerTools now returns the count — no more hardcoding
-      const toolCount = registerTools(api, supabase, config);
-      promptState.toolCount = toolCount;
-      promptState.ready = true;
-      const agentLabel = config.agentId || "auto-detect";
-      api.logger.info(
-        `[ofiere] Ready — ${toolCount} meta-tools registered (agent: ${agentLabel})`,
-      );
-    } catch (e) {
-      const msg = e instanceof Error ? e.message : String(e);
-      promptState.connectError = msg;
-      promptState.ready = true;
-      api.logger.error(`[ofiere] Failed to initialize: ${msg}`);
-    }
-  },
-};
-
-export default ofierePlugin;
+// index.ts — Ofiere PM Plugin for OpenClaw
+// Matches Composio plugin pattern: plain object export + api.on()
+
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import { parseOfiereConfig } from "./src/config.js";
+import { getSupabase } from "./src/supabase.js";
+import { registerTools, probeApiForAgentName } from "./src/tools.js";
+import { getSystemPrompt } from "./src/prompt.js";
+import { registerCli } from "./src/cli.js";
+import { seedAgentCache } from "./src/agent-resolver.js";
+
+const ofierePlugin = {
+  id: "ofiere",
+  name: "Ofiere PM",
+  description:
+    "Manage Ofiere PM tasks, agents, and projects directly from the agent. " +
+    "Create tasks, update progress, assign agents — all synced to the dashboard in real time.",
+
+  register(api: OpenClawPluginApi) {
+    const config = parseOfiereConfig(api.pluginConfig);
+
+    // Always register CLI (even if disabled — so user can run `openclaw ofiere setup`)
+    registerCli(api);
+
+    if (!config.enabled) {
+      api.logger.debug?.("[ofiere] Plugin disabled via config");
+      return;
+    }
+
+    if (!config.supabaseUrl || !config.serviceRoleKey) {
+      api.logger.warn(
+        "[ofiere] Not configured. Run: openclaw ofiere setup",
+      );
+      return;
+    }
+
+    if (!config.userId) {
+      api.logger.warn(
+        "[ofiere] Missing userId. Run: openclaw ofiere setup",
+      );
+      return;
+    }
+
+    // ── Pre-seed agent cache if OFIERE_AGENT_ID is set (legacy mode) ──────
+    if (config.agentId) {
+      const callerName =
+        (api as any)?.agentContext?.accountId ||
+        (api as any)?.agentContext?.name ||
+        (api as any)?.currentAgent?.accountId ||
+        "";
+      if (callerName) {
+        seedAgentCache(callerName, config.userId, config.agentId);
+      }
+    }
+
+    // ── State for system prompt injection ──────────────────────────────────
+    const promptState = {
+      toolCount: 0,
+      agentId: config.agentId,
+      connectError: "",
+      ready: false,
+    };
+
+    // ── System prompt is built ONCE (it's static after init) ──────────────
+    // No hook needed here — the brain context hook in tools.ts uses
+    // prependSystemContext via getSystemPromptCached() to combine both
+    // in a single hook invocation, eliminating one serial hook call.
+    let cachedSystemPrompt = "";
+    const getSystemPromptCached = () => {
+      if (!cachedSystemPrompt) {
+        cachedSystemPrompt = getSystemPrompt(promptState);
+      }
+      return cachedSystemPrompt;
+    };
+
+    // Hook: inject BOTH system prompt + brain context in one call
+    api.on("before_prompt_build", () => ({
+      prependSystemContext: getSystemPromptCached(),
+    }));
+
+    // ── Connect to Supabase and register tools ────────────────────────────
+    try {
+      const supabase = getSupabase(config.supabaseUrl, config.serviceRoleKey);
+
+      // Probe the api object for any agent identity info (for debugging + fallback)
+      probeApiForAgentName(api, api.logger);
+
+      // registerTools now returns the count — no more hardcoding
+      const toolCount = registerTools(api, supabase, config);
+      promptState.toolCount = toolCount;
+      promptState.ready = true;
+      const agentLabel = config.agentId || "auto-detect";
+      api.logger.info(
+        `[ofiere] Ready — ${toolCount} meta-tools registered (agent: ${agentLabel})`,
+      );
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      promptState.connectError = msg;
+      promptState.ready = true;
+      api.logger.error(`[ofiere] Failed to initialize: ${msg}`);
+    }
+  },
+};
+
+export default ofierePlugin;

package/package.json

@@ -1,15 +1,24 @@
 {
   "name": "ofiere-openclaw-plugin",
-  "version": "4.54.2",
+  "version": "4.55.0",
   "type": "module",
   "description": "OpenClaw plugin for Ofiere PM - 17 meta-tools covering tasks, agents, projects, scheduling, knowledge, workflows, notifications, memory, prompts, constellation, space file management, execution plan builder, SOP management, agent brain, talent management, corporate frameworks, and agent office canvas",
-  "keywords": ["openclaw", "ofiere", "project-management", "agents", "plugin"],
+  "keywords": [
+    "openclaw",
+    "ofiere",
+    "project-management",
+    "agents",
+    "plugin"
+  ],
   "homepage": "https://github.com/gilanggemar/Ofiere",
   "repository": {
     "type": "git",
     "url": "https://github.com/gilanggemar/Ofiere.git"
   },
   "license": "MIT",
+  "engines": {
+    "node": ">=20"
+  },
   "main": "./dist/index.js",
   "files": [
     "index.ts",
@@ -45,6 +54,7 @@
     "zod": "^3.25.11"
   },
   "devDependencies": {
+    "@types/node": "^25.8.0",
     "typescript": "^5.6.0"
   }
 }

package/src/agent-resolver.ts

@@ -1,90 +1,90 @@
-// src/agent-resolver.ts — Dynamic agent identity resolution
-// Resolves an OpenClaw account name (e.g. "ivy") to a Ofiere agent UUID.
-// Caches lookups so only the first call per agent hits Supabase.
-// Auto-registers unknown agents so multi-agent setups work out of the box.
-
-import type { SupabaseClient } from "@supabase/supabase-js";
-
-const cache = new Map<string, string>();
-
-/**
- * Resolves an OpenClaw accountId to a Ofiere agent UUID.
- *
- * Strategy:
- *   1. Check in-memory cache
- *   2. Look up by name (case-insensitive) in agents table
- *   3. If not found, auto-register a new agent record
- *   4. Cache the result for subsequent calls
- *
- * @param accountId - The OpenClaw account name (e.g. "ivy", "daisy")
- * @param userId    - The Ofiere user UUID who owns this agent
- * @param supabase  - Supabase client
- * @returns The Ofiere agent UUID
- */
-export async function resolveAgentId(
-  accountId: string,
-  userId: string,
-  supabase: SupabaseClient,
-): Promise<string> {
-  if (!accountId) return "";
-
-  const cacheKey = `${userId}:${accountId}`;
-
-  // 1. Cache hit
-  if (cache.has(cacheKey)) {
-    return cache.get(cacheKey)!;
-  }
-
-  // 2. Look up by name OR codename in a single query (v4.30.0 optimization)
-  const { data: existing } = await supabase
-    .from("agents")
-    .select("id")
-    .eq("user_id", userId)
-    .or(`name.ilike.${accountId},codename.ilike.${accountId}`)
-    .limit(1)
-    .single();
-
-  if (existing?.id) {
-    cache.set(cacheKey, existing.id);
-    return existing.id;
-  }
-
-  // 3. Auto-register a new agent
-  const newId = `agent-${accountId.toLowerCase()}-${Date.now()}`;
-  const { data: created } = await supabase
-    .from("agents")
-    .insert({
-      id: newId,
-      user_id: userId,
-      name: accountId.charAt(0).toUpperCase() + accountId.slice(1).toLowerCase(),
-      codename: accountId.toLowerCase(),
-      status: "active",
-      role: "operative",
-      level: 1,
-      xp: 0,
-      created_at: new Date().toISOString(),
-    })
-    .select("id")
-    .single();
-
-  const resolvedId = created?.id || newId;
-  cache.set(cacheKey, resolvedId);
-  return resolvedId;
-}
-
-/**
- * Pre-warm the cache with a known mapping.
- * Used when OFIERE_AGENT_ID env var is set (legacy single-agent mode).
- */
-export function seedAgentCache(accountId: string, userId: string, agentId: string): void {
-  if (accountId && agentId) {
-    cache.set(`${userId}:${accountId}`, agentId);
-  }
-}
-
-/**
- * Clear the cache (useful for testing).
- */
-export function clearAgentCache(): void {
-  cache.clear();
-}
+// src/agent-resolver.ts — Dynamic agent identity resolution
+// Resolves an OpenClaw account name (e.g. "ivy") to a Ofiere agent UUID.
+// Caches lookups so only the first call per agent hits Supabase.
+// Auto-registers unknown agents so multi-agent setups work out of the box.
+
+import type { SupabaseClient } from "@supabase/supabase-js";
+
+const cache = new Map<string, string>();
+
+/**
+ * Resolves an OpenClaw accountId to a Ofiere agent UUID.
+ *
+ * Strategy:
+ *   1. Check in-memory cache
+ *   2. Look up by name (case-insensitive) in agents table
+ *   3. If not found, auto-register a new agent record
+ *   4. Cache the result for subsequent calls
+ *
+ * @param accountId - The OpenClaw account name (e.g. "ivy", "daisy")
+ * @param userId    - The Ofiere user UUID who owns this agent
+ * @param supabase  - Supabase client
+ * @returns The Ofiere agent UUID
+ */
+export async function resolveAgentId(
+  accountId: string,
+  userId: string,
+  supabase: SupabaseClient,
+): Promise<string> {
+  if (!accountId) return "";
+
+  const cacheKey = `${userId}:${accountId}`;
+
+  // 1. Cache hit
+  if (cache.has(cacheKey)) {
+    return cache.get(cacheKey)!;
+  }
+
+  // 2. Look up by name OR codename in a single query (v4.30.0 optimization)
+  const { data: existing } = await supabase
+    .from("agents")
+    .select("id")
+    .eq("user_id", userId)
+    .or(`name.ilike.${accountId},codename.ilike.${accountId}`)
+    .limit(1)
+    .single();
+
+  if (existing?.id) {
+    cache.set(cacheKey, existing.id);
+    return existing.id;
+  }
+
+  // 3. Auto-register a new agent
+  const newId = `agent-${accountId.toLowerCase()}-${Date.now()}`;
+  const { data: created } = await supabase
+    .from("agents")
+    .insert({
+      id: newId,
+      user_id: userId,
+      name: accountId.charAt(0).toUpperCase() + accountId.slice(1).toLowerCase(),
+      codename: accountId.toLowerCase(),
+      status: "active",
+      role: "operative",
+      level: 1,
+      xp: 0,
+      created_at: new Date().toISOString(),
+    })
+    .select("id")
+    .single();
+
+  const resolvedId = created?.id || newId;
+  cache.set(cacheKey, resolvedId);
+  return resolvedId;
+}
+
+/**
+ * Pre-warm the cache with a known mapping.
+ * Used when OFIERE_AGENT_ID env var is set (legacy single-agent mode).
+ */
+export function seedAgentCache(accountId: string, userId: string, agentId: string): void {
+  if (accountId && agentId) {
+    cache.set(`${userId}:${accountId}`, agentId);
+  }
+}
+
+/**
+ * Clear the cache (useful for testing).
+ */
+export function clearAgentCache(): void {
+  cache.clear();
+}