omoclaw 3.1.0 → 3.2.0

package/dist/handlers/user-events.d.ts

@@ -7,5 +7,6 @@ interface UserEventNotifier {
         promptText?: string;
     }): void;
 }
-export declare function handleUserEvent(event: Event, dedup: DedupEngine, state: SessionStateTracker, notify: UserEventNotifier): void;
+type DebugLogger = ((msg: string) => void) | undefined;
+export declare function handleUserEvent(event: Event, dedup: DedupEngine, state: SessionStateTracker, notify: UserEventNotifier, debugLog?: DebugLogger): void;
 export {};

package/dist/index.js

@@ -995,6 +995,7 @@ function handleSessionStatusEvent(event, dedup, state, timers, webhookFn, notify
 
 // src/handlers/user-events.ts
 var PROMPT_PREVIEW_MAX = 200;
+var PROMPT_FLUSH_DELAY_MS = 2000;
 function shortSessionID3(sessionID) {
   return sessionID.slice(0, 12);
 }
@@ -1010,77 +1011,129 @@ function asString(value) {
 function normalizePreviewText(input) {
   return input.replace(/\s+/g, " ").trim();
 }
-
-class PromptBuffer {
-  buffer = "";
-  append(text) {
-    this.buffer += text;
-  }
-  clear() {
-    this.buffer = "";
-  }
-  flush() {
-    const text = normalizePreviewText(this.buffer);
-    this.buffer = "";
-    return text.slice(0, PROMPT_PREVIEW_MAX);
+var seenMessageIDs = new Set;
+var SEEN_MAX = 5000;
+var pendingPrompts = new Map;
+function evictOldestSeen() {
+  if (seenMessageIDs.size <= SEEN_MAX)
+    return;
+  const first = seenMessageIDs.values().next().value;
+  if (first !== undefined)
+    seenMessageIDs.delete(first);
+}
+function flushPendingPrompt(messageID, notify, debugLog) {
+  const pending = pendingPrompts.get(messageID);
+  if (!pending)
+    return;
+  clearTimeout(pending.timer);
+  pendingPrompts.delete(messageID);
+  seenMessageIDs.add(messageID);
+  evictOldestSeen();
+  const preview = normalizePreviewText(pending.text).slice(0, PROMPT_PREVIEW_MAX);
+  if (!preview) {
+    debugLog?.(`User prompt SKIPPED (no text after flush): session=${shortSessionID3(pending.sessionID)} msg=${messageID}`);
+    return;
   }
+  debugLog?.(`User prompt FLUSHED: session=${shortSessionID3(pending.sessionID)} msg=${messageID} text="${preview.slice(0, 60)}..."`);
+  notify("user-prompt", `[OpenCode] User prompt submitted (${shortSessionID3(pending.sessionID)}): ${preview}`, pending.agent, { promptText: preview });
 }
-var promptBuffer = new PromptBuffer;
-function handleUserEvent(event, dedup, state, notify) {
+function handleUserEvent(event, dedup, state, notify, debugLog) {
   if (event.type === "session.created" || event.type === "session.updated") {
-    const info = asObject3(event.properties.info);
-    if (!info)
+    const info2 = asObject3(event.properties.info);
+    if (!info2)
       return;
-    const sessionID = asString(info.id);
-    if (!sessionID)
+    const sessionID2 = asString(info2.id);
+    if (!sessionID2)
       return;
-    const parentID = asString(info.parentID);
-    state.setParentID(sessionID, parentID || undefined);
-    return;
-  }
-  if (event.type === "tui.prompt.append") {
-    const text = event.properties.text;
-    if (typeof text === "string") {
-      promptBuffer.append(text);
+    const parentID = asString(info2.parentID);
+    if (parentID) {
+      state.setParentID(sessionID2, parentID);
+      debugLog?.(`ParentID tracked: ${shortSessionID3(sessionID2)} \u2192 parent=${shortSessionID3(parentID)}`);
     }
     return;
   }
   if (event.type === "tui.command.execute") {
     const command = event.properties.command;
-    if (command === "session.interrupt") {
-      const dedupKey = "user-interrupt:tui-command";
-      if (!dedup.shouldSend(dedupKey))
-        return;
-      notify("user-interrupt", "[OpenCode] User interrupt requested");
+    if (command !== "session.interrupt")
       return;
-    }
-    if (command === "prompt.clear") {
-      promptBuffer.clear();
-      return;
-    }
-    if (command === "prompt.submit") {
-      const preview = promptBuffer.flush();
-      if (!preview)
-        return;
-      const dedupKey = `user-prompt:submit:${Date.now()}`;
-      if (!dedup.shouldSend(dedupKey))
-        return;
-      notify("user-prompt", `[OpenCode] User prompt submitted: ${preview}`, undefined, { promptText: preview });
+    const dedupKey = "user-interrupt:tui-command";
+    if (!dedup.shouldSend(dedupKey))
       return;
-    }
+    notify("user-interrupt", "[OpenCode] User interrupt requested");
     return;
   }
   if (event.type === "session.error") {
-    const sessionID = event.properties.sessionID;
+    const sessionID2 = event.properties.sessionID;
     const errorObj = event.properties.error;
-    if (!sessionID || errorObj?.name !== "MessageAbortedError")
+    if (!sessionID2 || errorObj?.name !== "MessageAbortedError")
       return;
-    const dedupKey = `user-interrupt:session-error:${sessionID}`;
+    const dedupKey = `user-interrupt:session-error:${sessionID2}`;
     if (!dedup.shouldSend(dedupKey))
       return;
-    notify("user-interrupt", `[OpenCode] User interrupt (${shortSessionID3(sessionID)})`, state.getAgent(sessionID));
+    notify("user-interrupt", `[OpenCode] User interrupt (${shortSessionID3(sessionID2)})`, state.getAgent(sessionID2));
     return;
   }
+  if (event.type === "message.part.updated") {
+    const part = asObject3(event.properties.part);
+    if (!part)
+      return;
+    const messageID2 = asString(part.messageID);
+    if (!messageID2)
+      return;
+    const pending = pendingPrompts.get(messageID2);
+    if (!pending)
+      return;
+    if (asString(part.type) !== "text")
+      return;
+    if (part.synthetic === true) {
+      debugLog?.(`User prompt part SKIPPED (synthetic): msg=${messageID2}`);
+      seenMessageIDs.add(messageID2);
+      evictOldestSeen();
+      clearTimeout(pending.timer);
+      pendingPrompts.delete(messageID2);
+      return;
+    }
+    const partText = asString(part.text);
+    if (!partText)
+      return;
+    pending.text += (pending.text ? " " : "") + partText;
+    flushPendingPrompt(messageID2, notify, debugLog);
+    return;
+  }
+  if (event.type !== "message.updated")
+    return;
+  const info = asObject3(event.properties.info);
+  if (!info)
+    return;
+  if (asString(info.role) !== "user")
+    return;
+  const sessionID = asString(info.sessionID);
+  if (!sessionID)
+    return;
+  const messageID = asString(info.id);
+  if (!messageID)
+    return;
+  if (seenMessageIDs.has(messageID))
+    return;
+  if (pendingPrompts.has(messageID))
+    return;
+  if (state.hasParentID(sessionID)) {
+    debugLog?.(`User prompt SKIPPED (sub-agent): session=${shortSessionID3(sessionID)} msg=${messageID}`);
+    seenMessageIDs.add(messageID);
+    evictOldestSeen();
+    return;
+  }
+  debugLog?.(`User prompt PENDING: session=${shortSessionID3(sessionID)} msg=${messageID} (waiting for text parts)`);
+  const timer = setTimeout(() => {
+    flushPendingPrompt(messageID, notify, debugLog);
+  }, PROMPT_FLUSH_DELAY_MS);
+  pendingPrompts.set(messageID, {
+    sessionID,
+    messageID,
+    agent: state.getAgent(sessionID),
+    text: "",
+    timer
+  });
 }
 
 // src/project-config.ts
@@ -1819,7 +1872,7 @@ var SessionMonitorPlugin = async (ctx) => {
     event: async ({ event }) => {
       debugLog?.(`EVENT: ${event.type} props=${JSON.stringify(event.properties).slice(0, 200)}`);
       handleAgentEvent(event, state);
-      handleUserEvent(event, dedup, state, notifyByPolicy);
+      handleUserEvent(event, dedup, state, notifyByPolicy, debugLog);
       handlePermissionEvent(event, dedup, timers, state, notifyByPolicy);
       handleQuestionEvent(event, dedup, timers, state, notifyByPolicy);
       handleSessionStatusEvent(event, dedup, state, timers, sendRealtimeWebhook, notifyByPolicy, debugLog);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omoclaw",
-  "version": "3.1.0",
+  "version": "3.2.0",
   "description": "OpenCode session monitor plugin — native event-driven webhook notifications for session state changes",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",