@ynhcj/xiaoyi-channel 0.0.209-beta → 0.0.211-beta

package/dist/src/cspl/utils.js

@@ -1,7 +1,7 @@
 /*
  * 版权所有 (c) 华为技术有限公司 2026-2026
  */
-import { MAX_TEXT_LENGTH, regex, SECURITY_NOTICE, MAX_FILE_COUNT, MAX_COMMAND_LENGTH, CODE_FILE_EXTENSIONS, TOOL_INPUT_DEFAULT, FILE_EXTENSION_REGEX, TOOL_INPUT_ACTION } from './constants.js';
+import { MAX_TEXT_LENGTH, regex, SECURITY_NOTICE, MAX_FILE_COUNT, MAX_COMMAND_LENGTH, CODE_FILE_EXTENSIONS, FILE_EXTENSION_REGEX, RESULT_CODE_MAP } from './constants.js';
 import crypto from 'crypto';
 import fs from 'fs';
 import path from 'path';
@@ -46,7 +46,7 @@ export function extractResultText(event, toolName) {
     }
     return resultTexts.length > 0 ? resultTexts.join("; ") : "";
 }
-export function processText(resultText, api) {
+export function processText(resultText) {
     const questionText = filterText(resultText);
     // 检查是否超过4096字符限制，进行截断
     const { text: finalText, truncated } = validateAndTruncateText(questionText, MAX_TEXT_LENGTH);
@@ -69,8 +69,14 @@ export function parseSecurityResult(response) {
     if (securityResult !== securityResult.trim()) {
         throw new Error('Response.data.securityResult contains leading or trailing spaces');
     }
-    if (securityResult !== 'ACCEPT' && securityResult !== 'REJECT') {
-        throw new Error(`Response.data.securityResult must be "ACCEPT" or "REJECT". Actual value: "${securityResult}"`);
+    if (securityResult !== 'accept' && securityResult !== 'reject') {
+        throw new Error(`Response.data.securityResult must be "accept" or "reject". Actual value: "${securityResult}"`);
+    }
+    // 解析 resultCode 并打印错误日志
+    const resultCode = response.data?.resultCode;
+    if (resultCode !== undefined && resultCode !== null && resultCode !== 0) {
+        const errorMsg = RESULT_CODE_MAP[resultCode] || `Unknown error code: ${resultCode}`;
+        logger.error(`[SENTINEL HOOK] API returned resultCode=${resultCode}: ${errorMsg}`);
     }
     return { status: securityResult };
 }
@@ -177,56 +183,103 @@ export function getFileSizeInKB(filePath) {
         return 0;
     }
 }
-// 动态计算content字段长度，确保body总长度<=4096
-export function adjustContentLength(data, api, fields) {
-    const adjusted = { ...data };
-    let bodyStr = JSON.stringify(adjusted);
-    if (bodyStr.length <= MAX_TEXT_LENGTH) {
-        return adjusted;
+// 从taskId中提取sessionID（第一个&之前的内容）
+export function extractSessionId(taskId) {
+    if (!taskId)
+        return '';
+    const idx = taskId.indexOf('&');
+    return idx === -1 ? taskId : taskId.substring(0, idx);
+}
+// 从taskId中提取interActionID（第一个&和第二个&之间的值）
+export function extractInterActionId(taskId) {
+    if (!taskId)
+        return 1;
+    const parts = taskId.split('&');
+    if (parts.length >= 2) {
+        const id = parseInt(parts[1], 10);
+        if (!isNaN(id) && id > 0)
+            return id;
     }
-    // 需要截断指定字段
-    let lastFieldName = '';
-    for (const fieldName of fields) {
-        lastFieldName = fieldName;
-        bodyStr = JSON.stringify(adjusted);
-        const overSize = bodyStr.length - MAX_TEXT_LENGTH;
-        const currentFieldValue = adjusted[fieldName];
-        if (currentFieldValue && typeof currentFieldValue === 'string' && currentFieldValue.length > overSize) {
-            // 从字段头部开始截断
-            adjusted[fieldName] = currentFieldValue.substring(0, currentFieldValue.length - overSize);
-            logger.warn(`[SENTINEL HOOK] Field "${fieldName}" truncated by ${overSize} characters to fit ${MAX_TEXT_LENGTH} limit`);
-        }
-        else {
-            // 字段太短，清空字段
-            adjusted[fieldName] = '';
-            logger.warn(`[SENTINEL HOOK] Field "${fieldName}" cleared as it cannot fit within size limit`);
+    return 1;
+}
+// reqTime 生成工具函数
+function formatReqTime() {
+    const now = new Date();
+    const pad = (n, len = 2) => String(n).padStart(len, '0');
+    const ms = String(now.getMilliseconds()).padStart(3, '0');
+    return `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())} ` +
+        `${pad(now.getHours())}:${pad(now.getMinutes())}:${pad(now.getSeconds())}.${ms}+0800`;
+}
+// 构建工具输入新消息体（新接口格式）
+export function buildToolInputPayload(taskID, sessionID, toolName, toolArguments, toolCallId, interActionID, options) {
+    const callObj = {
+        type: 'function',
+        name: toolName,
+        arguments: toolArguments,
+        index: 0,
+        id: toolCallId
+    };
+    if (options?.file) {
+        callObj.file = [options.file];
+    }
+    return {
+        taskID,
+        sessionID,
+        businessID: 'xiaoyi_claw',
+        sceneID: 'ACTION_DETECT',
+        checkPoint: 4,
+        interActionID,
+        loginType: 'APP',
+        reqTime: formatReqTime(),
+        message: {
+            input: {
+                toolIn: [{
+                        toolCalls: [callObj]
+                    }]
+            }
         }
-        // 检查是否满足要求
-        bodyStr = JSON.stringify(adjusted);
-        if (bodyStr.length <= MAX_TEXT_LENGTH) {
-            break;
+    };
+}
+// 构建工具输出新消息体（新接口格式）
+export function buildToolOutputPayload(taskID, sessionID, funcName, content, toolCallId, interActionID) {
+    return {
+        taskID,
+        sessionID,
+        businessID: 'xiaoyi_claw',
+        sceneID: 'PROMPT_DETECT',
+        checkPoint: 6,
+        interActionID,
+        loginType: 'APP',
+        reqTime: formatReqTime(),
+        message: {
+            output: {
+                toolOut: [{
+                        funcName,
+                        content: [{
+                                type: 'text',
+                                rawText: content
+                            }],
+                        toolCallId
+                    }]
+            }
         }
-    }
-    bodyStr = JSON.stringify(adjusted);
-    if (bodyStr.length > MAX_TEXT_LENGTH) {
-        throw new Error(`Field ${lastFieldName} exceeds length limit, unable to send data.`);
-    }
-    return adjusted;
+    };
 }
-// 发送TOOL_INPUT请求并处理响应，返回扫描结果
-async function sendToolInputRequest(postText, api, sessionId) {
-    const response = await callApi(postText, api, sessionId, TOOL_INPUT_ACTION);
+// 发送新接口请求并处理响应，返回扫描结果（保留block/steer能力）
+async function sendToolInputRequest(payload, api, sessionId) {
+    const response = await callApi(payload, api, sessionId);
     const result = parseSecurityResult(response);
     logger.log(`[SENTINEL HOOK] TOOL_INPUT response: status=${result.status}`);
     return result;
 }
-// 处理exec工具的TOOL_INPUT数据采集，返回最终扫描结果
-export async function handleExecToolInput(event, api, sessionId) {
+// 处理exec工具的TOOL_INPUT数据采集，返回扫描结果（保留block/steer能力）
+export async function handleExecToolInput(event, api, sessionId, taskId) {
     const command = extractInputParams(event, 'exec');
     if (!command) {
         logger.log('[SENTINEL HOOK] No command found for exec tool');
         return null;
     }
+    const interActionID = extractInterActionId(taskId);
     // 解析命令提取文件路径
     const filePaths = extractFilePathsFromCommand(command);
     if (filePaths.length > 0) {
@@ -243,14 +296,17 @@ export async function handleExecToolInput(event, api, sessionId) {
             const fileHash = calculateContentHash(fileContent);
             const fileSize = getFileSizeInKB(filePath);
             const obsUrl = await uploadFileToObsMain(filePath, api, fileHash, sessionId);
-            const toolInputData = { ...TOOL_INPUT_DEFAULT, tool: 'exec', hash: fileHash, url: obsUrl, size: fileSize,
-                source: command, content: fileContent };
-            const adjustedData = adjustContentLength(toolInputData, api, ['content', 'source']);
-            const postText = JSON.stringify(adjustedData);
-            logger.log(`[SENTINEL HOOK] Sending TOOL_INPUT for file: ${path.basename(filePath)}, body length: ${postText.length}`);
+            // 截断 body 到 MAX_TEXT_LENGTH
+            let bodyContent = fileContent;
+            if (Buffer.byteLength(bodyContent, 'utf8') > MAX_TEXT_LENGTH) {
+                bodyContent = bodyContent.substring(0, MAX_TEXT_LENGTH);
+                logger.warn(`[SENTINEL HOOK] File content truncated to ${MAX_TEXT_LENGTH} characters`);
+            }
+            const toolInputPayload = buildToolInputPayload(taskId, sessionId, 'exec', command, event.toolCallId, interActionID, { file: { type: 'doc', url: obsUrl, hash: fileHash, size: fileSize, body: bodyContent } });
+            logger.log(`[SENTINEL HOOK] Sending TOOL_INPUT for file: ${path.basename(filePath)}, body length: ${JSON.stringify(toolInputPayload).length}`);
             try {
-                lastResult = await sendToolInputRequest(postText, api, sessionId);
-                if (lastResult.status === 'REJECT') {
+                lastResult = await sendToolInputRequest(toolInputPayload, api, sessionId);
+                if (lastResult.status === 'reject') {
                     return lastResult;
                 }
             }
@@ -268,33 +324,26 @@ export async function handleExecToolInput(event, api, sessionId) {
     else {
         // 场景2：直接执行代码（heredoc场景）
         logger.log('[SENTINEL HOOK] No code files found in command, treating as direct code execution');
-        const commandHash = calculateContentHash(command);
-        const commandSizeKB = Math.ceil(Buffer.byteLength(command, 'utf8') / 1024);
-        const toolInputData = { ...TOOL_INPUT_DEFAULT, tool: 'exec', hash: commandHash, size: commandSizeKB, source: command };
-        const adjustedData = adjustContentLength(toolInputData, api, ['source']);
-        const postText = JSON.stringify(adjustedData);
-        logger.log(`[SENTINEL HOOK] Sending TOOL_INPUT for direct code execution, body length: ${postText.length}`);
-        return await sendToolInputRequest(postText, api, sessionId);
+        const toolInputPayload = buildToolInputPayload(taskId, sessionId, 'exec', command, event.toolCallId, interActionID);
+        logger.log(`[SENTINEL HOOK] Sending TOOL_INPUT for direct code execution, body length: ${JSON.stringify(toolInputPayload).length}`);
+        return await sendToolInputRequest(toolInputPayload, api, sessionId);
     }
 }
-// 处理message工具的TOOL_INPUT数据采集，返回扫描结果
-export async function handleMessageToolInput(event, api, sessionId) {
+// 处理message工具的TOOL_INPUT数据采集，返回扫描结果（保留block/steer能力）
+export async function handleMessageToolInput(event, api, sessionId, taskId) {
     const message = extractInputParams(event, 'message');
     if (!message) {
         logger.log('[SENTINEL HOOK] No message found for message tool');
         return null;
     }
     logger.log(`[SENTINEL HOOK] Processing message tool input, message length: ${message.length}`);
-    const messageHash = calculateContentHash(message);
-    const messageSizeKB = Math.ceil(Buffer.byteLength(message, 'utf8') / 1024);
-    const toolInputData = { ...TOOL_INPUT_DEFAULT, tool: 'message', hash: messageHash, size: messageSizeKB, content: message };
-    const adjustedData = adjustContentLength(toolInputData, api, ['content']);
-    const postText = JSON.stringify(adjustedData);
-    logger.log(`[SENTINEL HOOK] Sending TOOL_INPUT for message, body length: ${postText.length}`);
-    return await sendToolInputRequest(postText, api, sessionId);
+    const interActionID = extractInterActionId(taskId);
+    const toolInputPayload = buildToolInputPayload(taskId, sessionId, 'message', message, event.toolCallId, interActionID);
+    logger.log(`[SENTINEL HOOK] Sending TOOL_INPUT for message, body length: ${JSON.stringify(toolInputPayload).length}`);
+    return await sendToolInputRequest(toolInputPayload, api, sessionId);
 }
-// 处理其他工具（非 exec 和非 message）的 TOOL_INPUT 数据采集，返回扫描结果
-export async function handleOtherToolInput(event, api, sessionId) {
+// 处理其他工具（非 exec 和非 message）的 TOOL_INPUT 数据采集，返回扫描结果（保留block/steer能力）
+export async function handleOtherToolInput(event, api, sessionId, taskId) {
     const params = event.params;
     if (!params) {
         logger.log('[SENTINEL HOOK] No params found for tool');
@@ -303,13 +352,8 @@ export async function handleOtherToolInput(event, api, sessionId) {
     logger.log(`[SENTINEL HOOK] Processing other tool input, toolName: ${event.toolName}`);
     // 将 params 序列化为 JSON 字符串
     const paramsJson = JSON.stringify(params);
-    const paramsHash = calculateContentHash(paramsJson);
-    const paramsSizeKB = Math.ceil(Buffer.byteLength(paramsJson, 'utf8') / 1024);
-    // 创建 toolInputData，将 params 放到 source 字段
-    const toolInputData = { ...TOOL_INPUT_DEFAULT, tool: event.toolName, hash: paramsHash, size: paramsSizeKB, content: paramsJson };
-    // 对 source 字段进行长度截断处理
-    const adjustedData = adjustContentLength(toolInputData, api, ['content']);
-    const postText = JSON.stringify(adjustedData);
-    logger.log(`[SENTINEL HOOK] Sending TOOL_INPUT for ${event.toolName}, body length: ${postText.length}`);
-    return await sendToolInputRequest(postText, api, sessionId);
+    const interActionID = extractInterActionId(taskId);
+    const toolInputPayload = buildToolInputPayload(taskId, sessionId, event.toolName, paramsJson, event.toolCallId, interActionID);
+    logger.log(`[SENTINEL HOOK] Sending TOOL_INPUT for ${event.toolName}, body length: ${JSON.stringify(toolInputPayload).length}`);
+    return await sendToolInputRequest(toolInputPayload, api, sessionId);
 }

package/dist/src/log-reporter/index.d.ts

@@ -1,6 +1,6 @@
 import type { LogReporterOptions } from "./types.js";
 /**
- * Start the log reporter. Runs the first scan immediately, then on the configured interval.
+ * Start the log reporter. Runs the first scan immediately, then on a 5-minute interval.
  * Returns a stop function.
  */
 export declare function startLogReporter(options: LogReporterOptions): Promise<() => void>;

package/dist/src/log-reporter/index.js

@@ -1,39 +1,182 @@
 // Log Reporter Framework
 // Self-contained periodic log scanner + uploader + reporter.
 // Start via startLogReporter(), stop via stopLogReporter().
-import { resolveLogFiles, loadConfig } from "./config-loader.js";
+import { readFileSync } from "fs";
+import { resolveLogFiles } from "./path-resolver.js";
 import { scanFile } from "./scanner.js";
-import { uploadIncrementalContent } from "./uploader.js";
+import { uploadContent } from "./uploader.js";
 import { sendReport } from "./reporter.js";
 import { loadCursorStore, saveCursorStore, setCursor } from "./cursor-store.js";
-import { join } from "path";
+import { parseAndFormatLogContent } from "./openclaw-parser.js";
+import { logger } from "../utils/logger.js";
+import crypto from "crypto";
+// ── Constants ────────────────────────────────────────────────────────────────
+const SCAN_INTERVAL_MS = 300000; // 5 minutes
+const CURSOR_PATH = "/home/sandbox/.openclaw/.xiaoyilogging/.log-reporter-cursor.json";
+const BAK_DIR = "/tmp/openclaw";
+const ENV_FILE_PATH = "/home/sandbox/.openclaw/.xiaoyienv";
+/** Hardcoded log monitors */
+const MONITORS = [
+    {
+        path: "/tmp/openclaw/openclaw-{year-month-day}.log",
+        businessType: "openclaw-gateway",
+        jsonParse: true,
+    },
+    {
+        path: "/tmp/openclaw/xiaoyi-channel-{year}{month}{day}.log",
+        businessType: "xiaoyi-channel",
+        jsonParse: false,
+    },
+    {
+        path: "/home/sandbox/.openclaw/workspace/logs/init_{year}{month}{day}_{hour}{minute}{second}.log",
+        businessType: "openclaw-init",
+        jsonParse: false,
+    },
+];
+// ── State ────────────────────────────────────────────────────────────────────
 let intervalId = null;
 let isRunning = false;
+// ── Helpers ──────────────────────────────────────────────────────────────────
 /**
- * Start the log reporter. Runs the first scan immediately, then on the configured interval.
+ * Read the .xiaoyienv file and extract required environment variables.
+ * Expected format: key=value, one per line. Lines starting with # are comments.
+ */
+function readEnvFile() {
+    let raw;
+    try {
+        raw = readFileSync(ENV_FILE_PATH, "utf-8");
+    }
+    catch {
+        throw new Error(`Environment file not found: ${ENV_FILE_PATH}`);
+    }
+    const env = {};
+    for (const line of raw.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#"))
+            continue;
+        const eqIdx = trimmed.indexOf("=");
+        if (eqIdx === -1)
+            continue;
+        const key = trimmed.substring(0, eqIdx).trim();
+        const value = trimmed.substring(eqIdx + 1).trim();
+        env[key] = value;
+    }
+    const required = ["SERVICE_URL", "PERSONAL-API-KEY", "PERSONAL-UID"];
+    for (const key of required) {
+        if (!env[key]) {
+            throw new Error(`Missing required env variable: ${key}`);
+        }
+    }
+    return {
+        serviceUrl: env["SERVICE_URL"],
+        apiKey: env["PERSONAL-API-KEY"],
+        uid: env["PERSONAL-UID"],
+    };
+}
+/** Generate a stable instance ID (UUID) */
+function generateInstanceId() {
+    return crypto.randomUUID();
+}
+// ── Public API ───────────────────────────────────────────────────────────────
+/**
+ * Start the log reporter. Runs the first scan immediately, then on a 5-minute interval.
  * Returns a stop function.
  */
 export async function startLogReporter(options) {
-    const config = loadConfig(options.configPath);
-    const cursorPath = join(config.bakDir, ".log-reporter-cursor.json");
-    console.log(`[log-reporter] Starting with interval ${config.scanIntervalMs}ms, ${config.logFiles.length} log file(s) configured`);
+    const env = readEnvFile();
+    const instanceId = generateInstanceId();
+    logger.log(`[log-reporter] Starting with interval ${SCAN_INTERVAL_MS}ms, ${MONITORS.length} monitor(s) configured`);
+    logger.log(`[log-reporter] Instance ID: ${instanceId}`);
     async function doScan() {
         if (isRunning)
             return; // skip if previous scan still running
         isRunning = true;
         try {
-            const cursorStore = loadCursorStore(cursorPath);
-            for (const logFile of config.logFiles) {
-                const resolvedFiles = resolveLogFiles(logFile.path);
-                console.log(`[log-reporter] Scanning "${logFile.name}": pattern=${logFile.path}, resolved ${resolvedFiles.length} file(s)`);
+            const cursorStore = loadCursorStore(CURSOR_PATH);
+            // Accumulated cursors to persist after a successful cycle
+            const pendingCursors = {};
+            // Phase 1: Scan all monitors, aggregate content by businessType
+            const contentMap = new Map();
+            const cursorMap = new Map();
+            for (const monitor of MONITORS) {
+                const resolvedFiles = resolveLogFiles(monitor.path);
+                logger.log(`[log-reporter] Scanning "${monitor.businessType}": pattern=${monitor.path}, resolved ${resolvedFiles.length} file(s)`);
+                const btCursors = {};
+                const btParts = [];
                 for (const filePath of resolvedFiles) {
-                    await processFile(filePath, logFile.name, config, cursorStore, options);
+                    try {
+                        const result = await scanFile(filePath, cursorStore);
+                        if (!result)
+                            continue;
+                        // Apply JSON parsing for openclaw gateway logs
+                        const finalContent = monitor.jsonParse
+                            ? parseAndFormatLogContent(result.content)
+                            : result.content;
+                        if (!finalContent)
+                            continue;
+                        btParts.push(finalContent);
+                        btCursors[filePath] = result.newCursor;
+                    }
+                    catch (err) {
+                        logger.error(`[log-reporter] Error scanning "${filePath}": ${String(err)}`);
+                        // Don't persist cursors for this business type on any error
+                    }
+                }
+                if (btParts.length > 0) {
+                    const existing = contentMap.get(monitor.businessType);
+                    contentMap.set(monitor.businessType, existing ? existing + "\n" + btParts.join("\n") : btParts.join("\n"));
+                    cursorMap.set(monitor.businessType, btCursors);
                 }
             }
-            saveCursorStore(cursorPath, cursorStore);
+            // Phase 2: Skip if no content at all
+            if (contentMap.size === 0) {
+                logger.log("[log-reporter] No new content across all monitors, skipping report");
+                saveCursorStore(CURSOR_PATH, cursorStore);
+                return;
+            }
+            // Phase 3: Upload each business type's content → get URL
+            const logFiles = [];
+            for (const [businessType, content] of contentMap) {
+                try {
+                    const url = await uploadContent(content, businessType, BAK_DIR, options.uploadService);
+                    logger.log(`[log-reporter] Uploaded content for "${businessType}", url: ${url}`);
+                    logFiles.push({ businessType, fileUrl: url });
+                    // Merge cursors for successful uploads
+                    const btCursors = cursorMap.get(businessType);
+                    if (btCursors) {
+                        for (const [fp, cursor] of Object.entries(btCursors)) {
+                            pendingCursors[fp] = cursor;
+                        }
+                    }
+                }
+                catch (err) {
+                    logger.error(`[log-reporter] Upload failed for "${businessType}": ${String(err)}`);
+                    // Don't persist cursors for this business type — will retry next cycle
+                }
+            }
+            if (logFiles.length === 0) {
+                logger.log("[log-reporter] All uploads failed, skipping report");
+                return;
+            }
+            // Phase 4: Send report
+            const payload = { instanceId, logFiles };
+            try {
+                await sendReport(payload, env);
+            }
+            catch (err) {
+                logger.error(`[log-reporter] Report failed: ${String(err)}`);
+                // Don't persist cursors on report failure — will retry next cycle
+                return;
+            }
+            // Phase 5: Persist cursors after successful upload + report
+            for (const [fp, cursor] of Object.entries(pendingCursors)) {
+                setCursor(cursorStore, fp, cursor);
+            }
+            saveCursorStore(CURSOR_PATH, cursorStore);
         }
         catch (err) {
-            console.error("[log-reporter] Scan failed:", err);
+            logger.error(`[log-reporter] Scan failed: ${String(err)}`);
+            // Cursor NOT updated — will retry on next cycle
         }
         finally {
             isRunning = false;
@@ -42,29 +185,10 @@ export async function startLogReporter(options) {
     // Run first scan immediately
     await doScan();
     // Schedule periodic scans
-    intervalId = setInterval(doScan, config.scanIntervalMs);
+    intervalId = setInterval(doScan, SCAN_INTERVAL_MS);
     intervalId.unref?.();
     return () => stopLogReporter();
 }
-async function processFile(filePath, name, config, cursorStore, options) {
-    try {
-        const result = await scanFile(filePath, name, cursorStore);
-        if (!result)
-            return;
-        console.log(`[log-reporter] New content in "${name}": ${filePath} lines ${result.lineStart}-${result.lineEnd} (${result.newLineCount} lines)`);
-        // Upload .bak → get URL
-        const url = await uploadIncrementalContent(result, config.bakDir, options.uploadService);
-        console.log(`[log-reporter] Uploaded .bak for "${name}", url: ${url}`);
-        // Send report (mock)
-        await sendReport(config.reportUrl, url, result);
-        // Only persist cursor after successful upload + report
-        setCursor(cursorStore, filePath, result.newCursor);
-    }
-    catch (err) {
-        console.error(`[log-reporter] Failed processing "${name}" (${filePath}):`, err);
-        // Cursor NOT updated — will retry on next scan
-    }
-}
 /**
  * Stop the log reporter timer.
  */
@@ -72,6 +196,6 @@ export function stopLogReporter() {
     if (intervalId !== null) {
         clearInterval(intervalId);
         intervalId = null;
-        console.log("[log-reporter] Stopped");
+        logger.log("[log-reporter] Stopped");
     }
 }

package/dist/src/log-reporter/openclaw-parser.d.ts

@@ -0,0 +1,18 @@
+type ParsedLogLine = {
+    time?: string;
+    level?: string;
+    subsystem?: string;
+    module?: string;
+    message: string;
+    raw: string;
+};
+/** Parse a single raw JSON log line into structured fields. Returns null for non-JSON lines. */
+export declare function parseLogLine(raw: string): ParsedLogLine | null;
+/** Format a parsed log line as: "time level subsystem message" (matching openclaw logs output) */
+export declare function formatParsedLogLine(parsed: ParsedLogLine): string;
+/**
+ * Parse and format all lines in a raw log content block.
+ * JSON lines are parsed and formatted; non-JSON lines are passed through unchanged.
+ */
+export declare function parseAndFormatLogContent(rawContent: string): string;
+export {};

package/dist/src/log-reporter/openclaw-parser.js

@@ -0,0 +1,94 @@
+// OpenClaw JSON log line parser
+// Inlined from ~/code/openclaw/src/logging/parse-log-line.ts
+// Parses tslog JSON log lines into human-readable text format matching "openclaw logs --follow" output
+function trimLower(raw) {
+    if (typeof raw !== "string")
+        return undefined;
+    const trimmed = raw.trim();
+    return trimmed ? trimmed.toLowerCase() : undefined;
+}
+function extractMessage(value) {
+    const parts = [];
+    for (const key of Object.keys(value)) {
+        if (!/^\d+$/.test(key))
+            continue;
+        const item = value[key];
+        if (typeof item === "string") {
+            parts.push(item);
+        }
+        else if (item != null) {
+            parts.push(JSON.stringify(item));
+        }
+    }
+    return parts.join(" ");
+}
+function parseMetaName(raw) {
+    if (typeof raw !== "string")
+        return {};
+    try {
+        const parsed = JSON.parse(raw);
+        return {
+            subsystem: typeof parsed.subsystem === "string" ? parsed.subsystem : undefined,
+            module: typeof parsed.module === "string" ? parsed.module : undefined,
+        };
+    }
+    catch {
+        return {};
+    }
+}
+/** Parse a single raw JSON log line into structured fields. Returns null for non-JSON lines. */
+export function parseLogLine(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        const meta = parsed["_meta"];
+        const nameMeta = parseMetaName(meta?.name);
+        const levelRaw = typeof meta?.logLevelName === "string" ? meta.logLevelName : undefined;
+        return {
+            time: typeof parsed.time === "string"
+                ? parsed.time
+                : typeof meta?.date === "string"
+                    ? meta.date
+                    : undefined,
+            level: trimLower(levelRaw),
+            subsystem: nameMeta.subsystem,
+            module: nameMeta.module,
+            message: extractMessage(parsed),
+            raw,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/** Format a parsed log line as: "time level subsystem message" (matching openclaw logs output) */
+export function formatParsedLogLine(parsed) {
+    const parts = [];
+    if (parsed.time)
+        parts.push(parsed.time);
+    if (parsed.level)
+        parts.push(parsed.level.toUpperCase());
+    if (parsed.subsystem)
+        parts.push(parsed.subsystem);
+    if (parsed.message)
+        parts.push(parsed.message);
+    return parts.join(" ");
+}
+/**
+ * Parse and format all lines in a raw log content block.
+ * JSON lines are parsed and formatted; non-JSON lines are passed through unchanged.
+ */
+export function parseAndFormatLogContent(rawContent) {
+    const lines = rawContent.split("\n");
+    const formatted = [];
+    for (const line of lines) {
+        const parsed = parseLogLine(line);
+        if (parsed) {
+            formatted.push(formatParsedLogLine(parsed));
+        }
+        else if (line.length > 0) {
+            // Pass through non-JSON, non-empty lines as-is
+            formatted.push(line);
+        }
+    }
+    return formatted.join("\n");
+}

package/dist/src/log-reporter/path-resolver.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Resolve a path template with date wildcards to actual file paths on disk.
+ * Scans the directory and returns all files matching the pattern.
+ */
+export declare function resolveLogFiles(templatePath: string): string[];