@marenfei/message-logger-plugin 0.1.2

package/index.ts

@@ -0,0 +1,856 @@
+/**
+ * Message Logger Plugin
+ *
+ * Logs gateway lifecycle events to /tmp/plugin-message-hook.log using plugin hooks:
+ *   message_received, session_start, before_model_resolve, before_prompt_build,
+ *   llm_input, llm_output, before_tool_call, after_tool_call, agent_end,
+ *   message_sending, message_sent, session_end
+ * Includes gateway instance information in each log entry.
+ *
+ * NOTE: Gateway instance info is collected directly via Node.js APIs to avoid
+ * coupling with internal source code, ensuring easier upgrades.
+ */
+
+import {AsyncLocalStorage} from "node:async_hooks";
+import fs from "node:fs/promises";
+import fsSync from "node:fs";
+import {createRequire} from "node:module";
+import os from "node:os";
+import type {OpenClawPluginApi} from "openclaw/plugin-sdk";
+
+
+const LOG_FILE = "/tmp/plugin-message-hook.log";
+const SESSION_KEY_HEADER = "X-Session-Key";
+const SESSION_ID_HEADER = "X-Session-Id";
+const CRON_TRIGGER_HEADER = "X-Cron-Trigger";
+const LLM_REQUEST_URL_PREFIX = "https://mmc.sankuai.com/openclaw/v1";
+
+type LlmRequestContext = {
+    sessionKey?: string;
+    sessionId?: string;
+    isCronTrigger?: boolean;
+};
+
+const llmRequestContextStorage = new AsyncLocalStorage<LlmRequestContext>();
+
+type PatchedFetchGlobal = typeof globalThis & {
+    fetch?: (input: unknown, init?: unknown) => Promise<unknown>;
+    __openclawPluginsHookFetchPatched?: boolean;
+};
+
+type HeadersLike = {
+    set: (name: string, value: string) => void;
+    forEach?: (callback: (value: string, key: string) => void) => void;
+};
+
+function parseRequestUrl(input: unknown): string | undefined {
+    if (typeof input === "string") {
+        return input;
+    }
+
+    if (typeof input === "object" && input !== null && "url" in input) {
+        const maybeUrl = (input as { url?: unknown }).url;
+        if (typeof maybeUrl === "string") {
+            return maybeUrl;
+        }
+    }
+
+    if (typeof input === "object" && input !== null && "href" in input) {
+        const maybeHref = (input as { href?: unknown }).href;
+        if (typeof maybeHref === "string") {
+            return maybeHref;
+        }
+    }
+
+    return undefined;
+}
+
+function shouldAttachSessionKeyHeaders(url: string | undefined): boolean {
+    if (!url) {
+        return false;
+    }
+
+    return url.startsWith(LLM_REQUEST_URL_PREFIX);
+}
+
+function getHeadersCtor(): (new (init?: unknown) => HeadersLike) | undefined {
+    return (globalThis as { Headers?: new (init?: unknown) => HeadersLike }).Headers;
+}
+
+function mergeHeaders(baseHeaders: unknown, overrideHeaders: unknown): unknown {
+    const headersCtor = getHeadersCtor();
+    if (typeof headersCtor === "function") {
+        const merged = new headersCtor(baseHeaders);
+        if (overrideHeaders !== undefined) {
+            const override = new headersCtor(overrideHeaders);
+            if (typeof override.forEach === "function") {
+                override.forEach((value, key) => {
+                    merged.set(key, value);
+                });
+            }
+        }
+        return merged;
+    }
+
+    if (overrideHeaders !== undefined) {
+        return overrideHeaders;
+    }
+
+    return baseHeaders;
+}
+
+function mergeHeadersWithRequestContext(existingHeaders: unknown, requestContext: LlmRequestContext): unknown {
+    const headerEntries: Array<[string, string]> = [];
+    if (requestContext.sessionKey) {
+        headerEntries.push([SESSION_KEY_HEADER, requestContext.sessionKey]);
+    }
+    if (requestContext.sessionId) {
+        headerEntries.push([SESSION_ID_HEADER, requestContext.sessionId]);
+    }
+    if (requestContext.isCronTrigger) {
+        headerEntries.push([CRON_TRIGGER_HEADER, "true"]);
+    }
+
+    if (headerEntries.length === 0) {
+        return existingHeaders;
+    }
+
+    const headersCtor = getHeadersCtor();
+    if (typeof headersCtor === "function") {
+        const headers = new headersCtor(existingHeaders);
+        for (const [key, value] of headerEntries) {
+            headers.set(key, value);
+        }
+        return headers;
+    }
+
+    if (Array.isArray(existingHeaders)) {
+        return [...existingHeaders, ...headerEntries];
+    }
+
+    const contextHeaders = Object.fromEntries(headerEntries);
+    if (existingHeaders && typeof existingHeaders === "object") {
+        return {
+            ...(existingHeaders as Record<string, unknown>),
+            ...contextHeaders,
+        };
+    }
+
+    return contextHeaders;
+}
+
+function getRequestHeaders(input: unknown): unknown {
+    if (typeof input === "object" && input !== null && "headers" in input) {
+        return (input as { headers?: unknown }).headers;
+    }
+
+    return undefined;
+}
+
+function withRequestContextHeaders(input: unknown, init: unknown, requestContext: LlmRequestContext): Record<string, unknown> {
+    const baseInit = init && typeof init === "object" ? { ...(init as Record<string, unknown>) } : {};
+    const requestHeaders = getRequestHeaders(input);
+    const mergedHeaders = mergeHeaders(requestHeaders, baseInit.headers);
+    baseInit.headers = mergeHeadersWithRequestContext(mergedHeaders, requestContext);
+    return baseInit;
+}
+
+function installLlmRequestHeaderFetchInterceptor(
+    onLog?: (entry: Record<string, unknown>) => void,
+): void {
+    const globalState = globalThis as PatchedFetchGlobal;
+    if (typeof globalState.fetch !== "function") {
+        onLog?.({
+            hookType: "llm_header_interceptor_skip",
+            reason: "global_fetch_unavailable",
+        });
+        return;
+    }
+
+    if (globalState.__openclawPluginsHookFetchPatched) {
+        onLog?.({
+            hookType: "llm_header_interceptor_skip",
+            reason: "already_patched",
+        });
+        return;
+    }
+
+    const originalFetch = globalState.fetch.bind(globalThis);
+    globalState.__openclawPluginsHookFetchPatched = true;
+
+    onLog?.({
+        hookType: "llm_header_interceptor_installed",
+        urlPrefix: LLM_REQUEST_URL_PREFIX,
+        headerNames: [SESSION_KEY_HEADER, SESSION_ID_HEADER, CRON_TRIGGER_HEADER],
+    });
+
+    globalState.fetch = async (input: unknown, init?: unknown): Promise<unknown> => {
+        const url = parseRequestUrl(input);
+        if (!shouldAttachSessionKeyHeaders(url)) {
+            return originalFetch(input, init);
+        }
+
+        const requestContext = llmRequestContextStorage.getStore();
+        if (!requestContext?.sessionKey && !requestContext?.sessionId && !requestContext?.isCronTrigger) {
+            onLog?.({
+                hookType: "llm_header_inject_skip",
+                reason: "missing_ctx",
+                targetUrl: url,
+            });
+            return originalFetch(input, init);
+        }
+
+        const headerNames = [
+            requestContext.sessionKey ? SESSION_KEY_HEADER : undefined,
+            requestContext.sessionId ? SESSION_ID_HEADER : undefined,
+            requestContext.isCronTrigger ? CRON_TRIGGER_HEADER : undefined,
+        ].filter((name): name is string => Boolean(name));
+
+        onLog?.({
+            hookType: "llm_header_inject",
+            targetUrl: url,
+            sessionId: requestContext.sessionId,
+            hasSessionKey: Boolean(requestContext.sessionKey),
+            isCronTrigger: Boolean(requestContext.isCronTrigger),
+            headerNames,
+        });
+
+        return originalFetch(input, withRequestContextHeaders(input, init, requestContext));
+    };
+}
+
+type BridgeRequestContext = {
+    traceId?: string;
+    senderMisId?: string;
+};
+
+type BridgeStorageLike = {
+    getStore: () => BridgeRequestContext | undefined;
+};
+
+const DAXIANG_BRIDGE_MODULE_CANDIDATES = [
+    "@catclaw/daxiang/src/bridge-context.ts",
+    "@catclaw/daxiang/src/bridge-context.js",
+    "../daxiang/src/bridge-context.ts",
+    "../daxiang/dist/index.mjs",
+];
+
+const requireResolver = createRequire(import.meta.url);
+
+function canResolveModuleSpecifier(modulePath: string): boolean {
+    try {
+        requireResolver.resolve(modulePath);
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+let sharedBridgeStorage: BridgeStorageLike | null = null;
+let bridgeStorageLoadPromise: Promise<void> | null = null;
+
+async function ensureBridgeStorageLoaded(logDebug?: (message: string) => void): Promise<void> {
+    if (sharedBridgeStorage) {
+        return;
+    }
+
+    if (!bridgeStorageLoadPromise) {
+        bridgeStorageLoadPromise = (async () => {
+            for (const modulePath of DAXIANG_BRIDGE_MODULE_CANDIDATES) {
+                if (!canResolveModuleSpecifier(modulePath)) {
+                    logDebug?.(`[trace-bridge] module not found, skip import: ${modulePath}`);
+                    continue;
+                }
+
+                try {
+                    const mod = await import(modulePath);
+                    const maybeStorage = (mod as { bridgeStorage?: BridgeStorageLike }).bridgeStorage;
+                    if (maybeStorage && typeof maybeStorage.getStore === "function") {
+                        sharedBridgeStorage = maybeStorage;
+                        return;
+                    }
+                } catch (err) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    logDebug?.(`[trace-bridge] import failed from ${modulePath}: ${message}`);
+                }
+            }
+        })();
+    }
+
+    await bridgeStorageLoadPromise;
+}
+
+export function readSharedBridgeContext(): BridgeRequestContext {
+    try {
+        if (!sharedBridgeStorage) {
+            return {};
+        }
+        const store = sharedBridgeStorage.getStore();
+        return {
+            traceId: store?.traceId,
+            senderMisId: store?.senderMisId,
+        };
+    } catch {
+        return {};
+    }
+}
+
+export function __setSharedBridgeStorageForTest(storage: BridgeStorageLike | null): void {
+    sharedBridgeStorage = storage;
+    bridgeStorageLoadPromise = null;
+}
+
+export default function register(api: OpenClawPluginApi) {
+
+    /**
+     * Truncate content fields to a maximum of 30 characters.
+     * For strings: truncates if longer than 30 chars.
+     * For objects/arrays: recursively processes all string values within.
+     * Other types: returned as-is.
+     */
+    const truncateContent = (content: unknown): unknown => {
+        // Handle null/undefined
+        if (content === null || content === undefined) {
+            return content;
+        }
+
+        // Handle strings - truncate if needed
+        if (typeof content === "string") {
+            return content.length > 30 ? content.slice(0, 30) + "..." : content;
+        }
+
+        // Handle arrays - recursively process each item
+        if (Array.isArray(content)) {
+            return content.map(item => truncateContent(item));
+        }
+
+        // Handle objects - recursively process each property
+        if (typeof content === "object") {
+            const result: Record<string, unknown> = {};
+            for (const [key, value] of Object.entries(content)) {
+                result[key] = truncateContent(value);
+            }
+            return result;
+        }
+
+        // Handle other types (number, boolean, etc.)
+        return content;
+    };
+
+    /**
+     * Parse jobId from sessionKey.
+     * Supports both "cron:<jobId>" and "<prefix>:cron:<jobId>" formats.
+     *
+     * @returns jobId string, or undefined if sessionKey is not a cron session
+     */
+    const parseJobIdFromSessionKey = (sessionKey: string | undefined): string | undefined => {
+        if (!sessionKey) {
+            return undefined;
+        }
+        const segments = sessionKey.split(":");
+        const cronIndex = segments.lastIndexOf("cron");
+        if (cronIndex === -1 || cronIndex >= segments.length - 1) {
+            return undefined;
+        }
+        return segments[cronIndex + 1] || undefined;
+    };
+
+    /**
+     * Cron job type definition (minimal fields needed for plugin)
+     * Based on src/cron/types.ts CronJob and CronJobState
+     */
+    type CronJobInfo = {
+        id: string;
+        name: string;
+        enabled: boolean;
+        description?: string;
+        schedule: {
+            kind: "at" | "every" | "cron";
+            expr?: string;
+            everyMs?: number;
+            at?: string;
+            tz?: string;
+            staggerMs?: number;
+        };
+        payload: {
+            kind: "systemEvent" | "agentTurn";
+            message?: string;
+            text?: string;
+            model?: string;
+        };
+        delivery?: {
+            mode: "none" | "announce" | "webhook";
+            channel?: string;
+            to?: string;
+        };
+        state?: {
+            nextRunAtMs?: number;
+            lastRunAtMs?: number;
+            lastRunStatus?: "ok" | "error" | "skipped";
+            lastError?: string;
+            lastDurationMs?: number;
+        };
+    };
+
+    type CronJobsFile = {
+        version: 1;
+        jobs: CronJobInfo[];
+    };
+
+    /**
+     * Get cron job info by jobId from jobs.json.
+     *
+     * @param jobId - The cron job ID
+     * @returns CronJobInfo object, or undefined if not found or file cannot be read
+     */
+    const getCronJobById = async (jobId: string): Promise<CronJobInfo | undefined> => {
+        try {
+            const homeDir = os.homedir();
+            const jobsPath = `${homeDir}/.openclaw/cron/jobs.json`;
+            const content = await fs.readFile(jobsPath, "utf-8");
+            const jobsFile = JSON.parse(content) as CronJobsFile;
+            if (!Array.isArray(jobsFile.jobs)) {
+                return undefined;
+            }
+            return jobsFile.jobs.find((job) => job.id === jobId);
+        } catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            // Best-effort lookup for plugin enrichment; don't block hook execution.
+            api.logger.warn(`Failed to read cron jobs.json: ${message}`);
+            return undefined;
+        }
+    };
+
+
+
+    /**
+     * Get the gateway instance info using Node.js APIs.
+     * This approach avoids dependency on internal source code.
+     *
+     * instanceIp: first non-loopback IPv4 address from os.networkInterfaces().
+     */
+    const getGatewayInstanceInfo = (): Record<string, unknown> => {
+        const host = os.hostname();
+
+        return {
+            instanceHost: host
+        };
+    };
+
+    /**
+     * Format a Unix millisecond timestamp into the two fields added to every log entry:
+     *   eventTime — "yyyy-MM-dd HH:mm:ss.SSS" in Asia/Shanghai (UTC+8)
+     *   eventAt   — 13-digit Unix milliseconds
+     */
+    const formatTimestampFields = (
+        ms: number,
+    ): {
+        eventTime: string;
+        eventAt: number;
+    } => {
+        // Shift to UTC+8 for display
+        const offsetMs = 8 * 60 * 60 * 1000;
+        const local = new Date(ms + offsetMs);
+        const iso = local.toISOString(); // always UTC representation after shift
+        // iso format: "2026-03-12T10:00:58.382Z"
+        const datePart = iso.slice(0, 10); // "2026-03-12"
+        const timePart = iso.slice(11, 23); // "10:00:58.382"
+        return {
+            eventTime: `${datePart} ${timePart}`,
+            eventAt: ms,
+        };
+    };
+
+
+    /**
+     * Resolve the openclaw binary version.
+     *
+     * Priority:
+     *   1. Build-time global __OPENCLAW_VERSION__ (injected by openclaw's own bundle)
+     *   2. openclaw/package.json resolved via createRequire → "version" field
+     *   3. npm global node_modules: execSync("npm root -g") + /openclaw/package.json
+     *   4. /app/package.json  → "version" field
+     *   5. /app/dist/build-info.json → "version" field
+     *   fallback: "unknown"
+     */
+    const openclawVersion = (() => {
+        const readJsonSync = (filePath: string): Record<string, unknown> | null => {
+            try {
+                return JSON.parse(fsSync.readFileSync(filePath, "utf-8")) as Record<string, unknown>;
+            } catch {
+                return null;
+            }
+        };
+
+        // 1. Build-time injected global
+        const injected = (globalThis as Record<string, unknown>)["__OPENCLAW_VERSION__"];
+        if (typeof injected === "string" && injected.trim()) {
+            return injected.trim();
+        }
+
+        // 2. openclaw/package.json via createRequire
+        try {
+            const pkgPath = requireResolver.resolve("openclaw/package.json");
+            const pkg = readJsonSync(pkgPath);
+            if (typeof pkg?.version === "string" && (pkg.version as string).trim()) {
+                return (pkg.version as string).trim();
+            }
+        } catch {
+            // module not resolvable, fall through
+        }
+
+        // 3. npm global node_modules: `npm root -g` + /openclaw/package.json
+        try {
+            const { execSync } = requireResolver("node:child_process") as typeof import("node:child_process");
+            const globalRoot = execSync("npm root -g", { encoding: "utf-8" }).trim();
+            const pkg = readJsonSync(`${globalRoot}/openclaw/package.json`);
+            if (typeof pkg?.version === "string" && (pkg.version as string).trim()) {
+                return (pkg.version as string).trim();
+            }
+        } catch {
+            // npm not available or openclaw not installed globally, fall through
+        }
+
+        // 4. /app/package.json
+        const pkg = readJsonSync("/app/package.json");
+        if (typeof pkg?.version === "string" && (pkg.version as string).trim()) {
+            return (pkg.version as string).trim();
+        }
+
+        // 5. /app/dist/build-info.json
+        const info = readJsonSync("/app/dist/build-info.json");
+        if (typeof info?.version === "string" && (info.version as string).trim()) {
+            return (info.version as string).trim();
+        }
+
+        return "unknown";
+    })();
+
+    // Helper function to write log entries with instance info
+    const writeLog = async (entry: Record<string, unknown>) => {
+        const eventAt = Date.now();
+        try {
+            await ensureBridgeStorageLoaded((message) => api.logger.debug(message));
+            // Attach gateway instance info to every log entry
+            const instanceInfo = getGatewayInstanceInfo();
+            const bridgeCtx = readSharedBridgeContext();
+            const timestampFields = formatTimestampFields(eventAt);
+            const enrichedEntry = {
+                ...entry,
+                ...timestampFields,
+                ...instanceInfo,
+                openclawVersion,
+                ...(bridgeCtx.traceId ? {bridgeTraceId: bridgeCtx.traceId} : {bridgeTraceId : undefined}),
+                ...(bridgeCtx.senderMisId ? {bridgeSenderMisId: bridgeCtx.senderMisId} : {}),
+            };
+            const line = JSON.stringify(enrichedEntry) + "\n";
+
+            // Write to local file
+            await fs.appendFile(LOG_FILE, line, "utf-8");
+        } catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            api.logger.error(`Failed to write log: ${message}`);
+        }
+    };
+
+    installLlmRequestHeaderFetchInterceptor((entry) => {
+        api.logger.info(`[llm_header] ${JSON.stringify(entry)}`);
+    });
+
+    // Hook: message_received — captures inbound messages from channels
+    api.on(
+        "message_received",
+        async (event, ctx) => {
+            await writeLog({
+                hookType: "message_received",
+                from: event.from,
+                content: truncateContent(event.content),
+                eventTimestamp: event.timestamp,
+                metadata: event.metadata,
+                channelId: ctx.channelId,
+                accountId: ctx.accountId,
+                conversationId: ctx.conversationId,
+            });
+        },
+        {priority: 10},
+    );
+
+    // Hook: session_start — fires when a new session is created or resumed
+    api.on(
+        "session_start",
+        async (event, ctx) => {
+            await writeLog({
+                hookType: "session_start",
+                sessionId: event.sessionId,
+                sessionKey: event.sessionKey,
+                resumedFrom: event.resumedFrom,
+                agentId: ctx.agentId,
+            });
+        },
+        {priority: 10},
+    );
+
+    // Hook: before_model_resolve — fires before the model/provider is selected for a run
+    api.on(
+        "before_model_resolve",
+        (_event, ctx) => {
+            const isCronTrigger = Boolean(parseJobIdFromSessionKey(ctx.sessionKey) || ctx.trigger === "cron");
+            llmRequestContextStorage.enterWith({
+                sessionKey: ctx.sessionKey,
+                sessionId: ctx.sessionId,
+                isCronTrigger,
+            });
+
+            // Keep existing resolve logs without blocking context propagation.
+            void writeLog({
+                hookType: "before_model_resolve",
+                agentId: ctx.agentId,
+                sessionKey: ctx.sessionKey,
+                sessionId: ctx.sessionId,
+                channelId: ctx.channelId,
+                trigger: ctx.trigger,
+            });
+        },
+        {priority: 10},
+    );
+
+    // Hook: before_prompt_build — fires after session messages are ready, before prompt assembly
+    api.on(
+        "before_prompt_build",
+        async (event, ctx) => {
+            await writeLog({
+                hookType: "before_prompt_build",
+                messagesCount: Array.isArray(event.messages) ? event.messages.length : undefined,
+                agentId: ctx.agentId,
+                sessionKey: ctx.sessionKey,
+                sessionId: ctx.sessionId,
+                channelId: ctx.channelId,
+                trigger: ctx.trigger,
+            });
+        },
+        {priority: 10},
+    );
+
+    // Hook: llm_input — captures the full prompt sent to the LLM
+    api.on(
+        "llm_input",
+        async (event, ctx) => {
+            await writeLog({
+                hookType: "llm_input",
+                role: "user",
+                runId: event.runId,
+                sessionId: event.sessionId,
+                agentId: ctx.agentId,
+                sessionKey: ctx.sessionKey,
+                channelId: ctx.channelId,
+                provider: event.provider,
+                model: event.model,
+                imagesCount: event.imagesCount,
+            });
+        },
+        {priority: 10},
+    );
+
+    // Hook: llm_output — captures the assistant reply from the LLM
+    api.on(
+        "llm_output",
+        async (event, ctx) => {
+            // Extract stopReason and errorMessage from lastAssistant (typed as unknown)
+            const last = event.lastAssistant as
+                | { stopReason?: string; errorMessage?: string }
+                | undefined;
+            await writeLog({
+                hookType: "llm_output",
+                role: "assistant",
+                runId: event.runId,
+                sessionId: event.sessionId,
+                agentId: ctx.agentId,
+                sessionKey: ctx.sessionKey,
+                channelId: ctx.channelId,
+                provider: event.provider,
+                model: event.model,
+                assistantTexts: truncateContent(event.assistantTexts),
+                lastAssistantStopReason: last?.stopReason,
+                lastAssistantErrorMessage: last?.errorMessage,
+            });
+        },
+        {priority: 10},
+    );
+
+    // Hook: before_tool_call — captures tool invocations before execution
+    api.on(
+        "before_tool_call",
+        async (event, ctx) => {
+            await writeLog({
+                hookType: "before_tool_call",
+                role: "tool",
+                phase: "before",
+                runId: event.runId ?? ctx.runId,
+                sessionId: ctx.sessionId,
+                agentId: ctx.agentId,
+                sessionKey: ctx.sessionKey,
+                toolName: event.toolName,
+                toolCallId: event.toolCallId ?? ctx.toolCallId,
+                params: truncateContent(event.params),
+            });
+        },
+        {priority: 10},
+    );
+
+    // Hook: after_tool_call — captures tool results after execution
+    api.on(
+        "after_tool_call",
+        async (event, ctx) => {
+            await writeLog({
+                hookType: "after_tool_call",
+                role: "tool",
+                phase: "after",
+                runId: event.runId ?? ctx.runId,
+                sessionId: ctx.sessionId,
+                agentId: ctx.agentId,
+                sessionKey: ctx.sessionKey,
+                toolName: event.toolName,
+                toolCallId: event.toolCallId ?? ctx.toolCallId,
+                params: truncateContent(event.params),
+                result: truncateContent(event.result),
+                error: event.error,
+                durationMs: event.durationMs,
+            });
+        },
+        {priority: 10},
+    );
+
+    // Hook: agent_end — captures the result of an agent run (success/failure, duration)
+    api.on(
+        "agent_end",
+        async (event, ctx) => {
+            const jobId = parseJobIdFromSessionKey(ctx.sessionKey);
+            const cronJob = jobId ? await getCronJobById(jobId) : undefined;
+            await writeLog({
+                hookType: "agent_end",
+                agentId: ctx.agentId,
+                sessionKey: ctx.sessionKey,
+                sessionId: ctx.sessionId,
+                channelId: ctx.channelId,
+                trigger: ctx.trigger,
+                success: event.success,
+                error: event.error,
+                durationMs: event.durationMs,
+                jobId: jobId,
+                cronJob: cronJob ? JSON.stringify(cronJob) : undefined,
+                messagesCount: Array.isArray(event.messages) ? event.messages.length : undefined,
+            });
+        },
+        {priority: 10},
+    );
+
+    // Hook: message_sending — fires just before an outbound message is dispatched
+    api.on(
+        "message_sending",
+        async (event, ctx) => {
+            await writeLog({
+                hookType: "message_sending",
+                to: event.to,
+                content: truncateContent(event.content),
+                metadata: event.metadata,
+                channelId: ctx.channelId,
+                accountId: ctx.accountId,
+                conversationId: ctx.conversationId,
+            });
+        },
+        {priority: 10},
+    );
+
+    // Hook: message_sent — fires after an outbound message has been delivered (or failed)
+    api.on(
+        "message_sent",
+        async (event, ctx) => {
+            await writeLog({
+                hookType: "message_sent",
+                to: event.to,
+                content: truncateContent(event.content),
+                success: event.success,
+                error: event.error,
+                channelId: ctx.channelId,
+                accountId: ctx.accountId,
+                conversationId: ctx.conversationId,
+            });
+        },
+        {priority: 10},
+    );
+
+    // Hook: session_end — fires when a session terminates
+    api.on(
+        "session_end",
+        async (event, ctx) => {
+            await writeLog({
+                hookType: "session_end",
+                sessionId: event.sessionId,
+                sessionKey: event.sessionKey,
+                messageCount: event.messageCount,
+                durationMs: event.durationMs,
+                agentId: ctx.agentId,
+            });
+        },
+        {priority: 10},
+    );
+
+    // Hook: before_reset — fires when /new or /reset clears a session
+    api.on(
+        "before_reset",
+        async (event, ctx) => {
+            await writeLog({
+                hookType: "before_reset",
+                sessionFile: event.sessionFile,
+                messagesCount: Array.isArray(event.messages) ? event.messages.length : undefined,
+                reason: event.reason,
+                agentId: ctx.agentId,
+                sessionKey: ctx.sessionKey,
+                sessionId: ctx.sessionId,
+            });
+        },
+        {priority: 10},
+    );
+
+    // Hook: subagent_spawned — fires when a subagent has been spawned
+    api.on(
+        "subagent_spawned",
+        async (event, ctx) => {
+            await writeLog({
+                hookType: "subagent_spawned",
+                childSessionKey: event.childSessionKey,
+                agentId: event.agentId,
+                label: event.label,
+                mode: event.mode,
+                threadRequested: event.threadRequested,
+                runId: event.runId,
+                requesterSessionKey: ctx.requesterSessionKey,
+            });
+        },
+        {priority: 10},
+    );
+
+    // Hook: subagent_ended — fires when a subagent session ends
+    api.on(
+        "subagent_ended",
+        async (event, ctx) => {
+            await writeLog({
+                hookType: "subagent_ended",
+                targetSessionKey: event.targetSessionKey,
+                targetKind: event.targetKind,
+                reason: event.reason,
+                sendFarewell: event.sendFarewell,
+                accountId: event.accountId,
+                runId: event.runId,
+                endedAt: event.endedAt,
+                outcome: event.outcome,
+                error: event.error,
+                childSessionKey: ctx.childSessionKey,
+                requesterSessionKey: ctx.requesterSessionKey,
+            });
+        },
+        {priority: 10},
+    );
+
+    api.logger.info(`Message logger plugin registered (logs to ${LOG_FILE})`);
+}

package/openclaw.plugin.json

@@ -0,0 +1,10 @@
+{
+  "id": "message-logger-plugin",
+  "name": "Message Logger Plugin",
+  "description": "Logs user, assistant, and tool messages to /tmp/plugin-message-hook.log using plugin hooks.",
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {}
+  }
+}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@marenfei/message-logger-plugin",
+  "version": "0.1.2",
+  "description": "OpenClaw message logger plugin using plugin hooks",
+  "type": "module",
+  "main": "./index.ts",
+  "files": [
+    "index.ts",
+    "openclaw.plugin.json",
+    "tsconfig.json"
+  ],
+  "keywords": [
+    "openclaw",
+    "plugin",
+    "message-logger",
+    "gateway"
+  ],
+  "author": "marenfei@meituan.com",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ee/openclaw-plugins-hook.git"
+  },
+  "dependencies": {},
+  "peerDependencies": {
+    "openclaw": ">=2026.2.0"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "openclaw": {
+    "extensions": [
+      "./index.ts"
+    ]
+  }
+}

package/tsconfig.json

@@ -0,0 +1,22 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2022"],
+    "outDir": "dist",
+    "declaration": true,
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "resolveJsonModule": true,
+    "allowSyntheticDefaultImports": true,
+    "forceConsistentCasingInFileNames": true,
+    "types": ["node"]
+  },
+  "include": ["index.ts"],
+  "exclude": [
+    "message-logger-plugin/node_modules"
+  ]
+}
+