@chbo297/infoflow 2026.2.23

package/src/monitor.ts

@@ -0,0 +1,177 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { OpenClawConfig } from "openclaw/plugin-sdk";
+import type { ResolvedInfoflowAccount } from "./channel.js";
+import {
+  parseAndDispatchInfoflowRequest,
+  loadRawBody,
+  type WebhookTarget,
+} from "./infoflow-req-parse.js";
+import { getInfoflowWebhookLog } from "./logging.js";
+import { getInfoflowRuntime } from "./runtime.js";
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export type InfoflowMonitorOptions = {
+  account: ResolvedInfoflowAccount;
+  config: OpenClawConfig;
+  runtime: unknown;
+  abortSignal: AbortSignal;
+  statusSink?: (patch: { lastInboundAt?: number; lastOutboundAt?: number }) => void;
+};
+
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+
+/** webhook path for Infoflow. */
+const INFOFLOW_WEBHOOK_PATH = "/webhook/infoflow";
+
+// ---------------------------------------------------------------------------
+// Webhook target registry
+// ---------------------------------------------------------------------------
+
+const webhookTargets = new Map<string, WebhookTarget[]>();
+
+/** Normalizes a webhook path: trim, ensure leading slash, strip trailing slash (except "/"). */
+function normalizeWebhookPath(raw: string): string {
+  const trimmed = raw.trim();
+  if (!trimmed) {
+    return "/";
+  }
+  const withSlash = trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+  if (withSlash.length > 1 && withSlash.endsWith("/")) {
+    return withSlash.slice(0, -1);
+  }
+  return withSlash;
+}
+
+/** Registers a webhook target for a path. Returns an unregister function to remove it. */
+function registerInfoflowWebhookTarget(target: WebhookTarget): () => void {
+  const key = normalizeWebhookPath(target.path);
+  const normalizedTarget = { ...target, path: key };
+  const existing = webhookTargets.get(key) ?? [];
+  const next = [...existing, normalizedTarget];
+  webhookTargets.set(key, next);
+  return () => {
+    const updated = (webhookTargets.get(key) ?? []).filter((entry) => entry !== normalizedTarget);
+    if (updated.length > 0) {
+      webhookTargets.set(key, updated);
+    } else {
+      webhookTargets.delete(key);
+    }
+  };
+}
+
+// ---------------------------------------------------------------------------
+// HTTP handler (registered via api.registerHttpHandler)
+// ---------------------------------------------------------------------------
+
+/**
+ * Checks if the request path matches a registered Infoflow webhook path.
+ */
+function isInfoflowPath(requestPath: string): boolean {
+  const normalized = normalizeWebhookPath(requestPath);
+  return webhookTargets.has(normalized);
+}
+
+/**
+ * Handles incoming Infoflow webhook HTTP requests.
+ *
+ * - Routes by path to registered targets (supports exact and suffix match).
+ * - Only allows POST.
+ * - Delegates body reading, echostr verification, authentication,
+ *   and message dispatch to infoflow_req_parse.
+ */
+export async function handleInfoflowWebhookRequest(
+  req: IncomingMessage,
+  res: ServerResponse,
+): Promise<boolean> {
+  const core = getInfoflowRuntime();
+  const verbose = core.logging.shouldLogVerbose();
+
+  const url = new URL(req.url ?? "/", "http://localhost");
+  const requestPath = normalizeWebhookPath(url.pathname);
+
+  if (verbose) {
+    // Log the full request URL
+    getInfoflowWebhookLog().debug?.(`[infoflow] request: url=${url}`);
+  }
+
+  // Check if path matches Infoflow webhook pattern
+  if (!isInfoflowPath(requestPath)) {
+    return false;
+  }
+
+  // Get registered targets for the actual request path
+  const targets = webhookTargets.get(requestPath);
+  if (!targets || targets.length === 0) {
+    return false;
+  }
+
+  if (req.method !== "POST") {
+    res.statusCode = 405;
+    res.setHeader("Allow", "POST");
+    res.end("Method Not Allowed");
+    return true;
+  }
+
+  // Load raw body once
+  const bodyResult = await loadRawBody(req);
+  if (!bodyResult.ok) {
+    getInfoflowWebhookLog().error(`[infoflow] failed to read body: ${bodyResult.error}`);
+    res.statusCode = bodyResult.error === "payload too large" ? 413 : 400;
+    res.end(bodyResult.error);
+    return true;
+  }
+
+  let result;
+  try {
+    result = await parseAndDispatchInfoflowRequest(req, bodyResult.raw, targets);
+  } catch (err) {
+    const errMsg = err instanceof Error ? err.message : String(err);
+    getInfoflowWebhookLog().error(`[infoflow] webhook handler error: ${errMsg}`);
+    res.statusCode = 500;
+    res.end("internal error");
+    return true;
+  }
+
+  if (verbose) {
+    getInfoflowWebhookLog().debug?.(
+      `[infoflow] dispatch result: handled=${result.handled}, status=${result.handled ? result.statusCode : "N/A"}`,
+    );
+  }
+
+  if (result.handled) {
+    const looksLikeJson = result.body.startsWith("{");
+    if (looksLikeJson) {
+      res.setHeader("Content-Type", "application/json");
+    }
+    res.statusCode = result.statusCode;
+    res.end(result.body);
+  } else {
+    res.statusCode = 200;
+    res.end("OK");
+  }
+  return true;
+}
+
+// ---------------------------------------------------------------------------
+// Monitor lifecycle
+// ---------------------------------------------------------------------------
+
+/** Registers this account's webhook target and returns an unregister (stop) function. */
+export async function startInfoflowMonitor(options: InfoflowMonitorOptions): Promise<() => void> {
+  const core = getInfoflowRuntime();
+
+  const unregister = registerInfoflowWebhookTarget({
+    account: options.account,
+    config: options.config,
+    core,
+    path: INFOFLOW_WEBHOOK_PATH,
+    statusSink: options.statusSink,
+  });
+
+  return unregister;
+}

package/src/reply-dispatcher.ts

@@ -0,0 +1,88 @@
+import {
+  createReplyPrefixOptions,
+  type OpenClawConfig,
+  type ReplyPayload,
+} from "openclaw/plugin-sdk";
+import { getInfoflowSendLog } from "./logging.js";
+import { getInfoflowRuntime } from "./runtime.js";
+import { sendInfoflowMessage } from "./send.js";
+import type { InfoflowAtOptions, InfoflowMessageContentItem } from "./types.js";
+
+export type CreateInfoflowReplyDispatcherParams = {
+  cfg: OpenClawConfig;
+  agentId: string;
+  accountId: string;
+  /** Target: "group:<id>" for group chat, username for private chat */
+  to: string;
+  statusSink?: (patch: { lastInboundAt?: number; lastOutboundAt?: number }) => void;
+  /** AT options for @mentioning members in group messages */
+  atOptions?: InfoflowAtOptions;
+};
+
+/**
+ * Builds dispatcherOptions and replyOptions for dispatchReplyWithBufferedBlockDispatcher.
+ * Encapsulates prefix options, chunked deliver (send via Infoflow API + statusSink), and onError.
+ */
+export function createInfoflowReplyDispatcher(params: CreateInfoflowReplyDispatcherParams) {
+  const { cfg, agentId, accountId, to, statusSink, atOptions } = params;
+  const core = getInfoflowRuntime();
+
+  const { onModelSelected, ...prefixOptions } = createReplyPrefixOptions({
+    cfg,
+    agentId,
+    channel: "infoflow",
+    accountId,
+  });
+
+  // Check if target is a group (format: group:<id>)
+  const isGroup = /^group:\d+$/i.test(to);
+
+  const deliver = async (payload: ReplyPayload) => {
+    const text = payload.text ?? "";
+    if (!text.trim()) {
+      return;
+    }
+
+    // Chunk text to 4000 chars max (Infoflow limit)
+    const chunks = core.channel.text.chunkText(text, 4000);
+    // Only include @mentions in the first chunk (avoid duplicate @s)
+    let isFirstChunk = true;
+
+    for (const chunk of chunks) {
+      const contents: InfoflowMessageContentItem[] = [{ type: "markdown", content: chunk }];
+
+      // Add AT content for group messages (first chunk only)
+      if (isFirstChunk && isGroup && atOptions) {
+        if (atOptions.atAll) {
+          contents.push({ type: "at", content: "all" });
+        } else if (atOptions.atUserIds?.length) {
+          contents.push({ type: "at", content: atOptions.atUserIds.join(",") });
+        }
+      }
+      isFirstChunk = false;
+
+      const result = await sendInfoflowMessage({ cfg, to, contents, accountId });
+
+      if (result.ok) {
+        statusSink?.({ lastOutboundAt: Date.now() });
+      } else if (result.error) {
+        getInfoflowSendLog().error(`[infoflow] Failed to send message: ${result.error}`);
+      }
+    }
+  };
+
+  const onError = (err: unknown) => {
+    getInfoflowSendLog().error(`[infoflow] reply failed: ${String(err)}`);
+  };
+
+  return {
+    dispatcherOptions: {
+      ...prefixOptions,
+      deliver,
+      onError,
+    },
+    replyOptions: {
+      onModelSelected,
+    },
+  };
+}

package/src/runtime.ts

@@ -0,0 +1,14 @@
+import type { PluginRuntime } from "openclaw/plugin-sdk";
+
+let runtime: PluginRuntime | null = null;
+
+export function setInfoflowRuntime(next: PluginRuntime) {
+  runtime = next;
+}
+
+export function getInfoflowRuntime(): PluginRuntime {
+  if (!runtime) {
+    throw new Error("Infoflow runtime not initialized");
+  }
+  return runtime;
+}