@ynhcj/xiaoyi-channel 0.0.193-next → 0.0.194-next

package/dist/index.d.ts

@@ -1,8 +1,3 @@
-declare const _default: {
-    id: string;
-    name: string;
-    description: string;
-    configSchema: import("openclaw/plugin-sdk").OpenClawPluginConfigSchema;
-    register: NonNullable<import("openclaw/plugin-sdk/core").OpenClawPluginDefinition["register"]>;
-} & Pick<import("openclaw/plugin-sdk/core").OpenClawPluginDefinition, "kind" | "reload" | "nodeHostCommands" | "securityAuditCollectors">;
-export default _default;
+import { definePluginEntry } from "openclaw/plugin-sdk/core";
+declare const pluginEntry: ReturnType<typeof definePluginEntry>;
+export default pluginEntry;

package/dist/index.js

@@ -10,6 +10,7 @@ import { getAllPushIds } from "./src/utils/pushid-manager.js";
 import { registerSelfEvolutionToolResultNudge } from "./src/self-evolution-tool-result-nudge.js";
 import { createBeforePromptBuildHandler } from "./src/skill-retriever/hooks.js";
 import { normalizeToolRetrieverConfig } from "./src/skill-retriever/config.js";
+import { registerCLIHook } from "./src/tools/hmos-cli.js";
 /**
  * Register the cron detection hook.
  *
@@ -181,7 +182,7 @@ function registerFullHooks(api) {
     api.on("before_prompt_build", beforePromptBuildHandler);
     registerSelfEvolutionToolResultNudge(api);
 }
-export default definePluginEntry({
+const pluginEntry = definePluginEntry({
     id: "xiaoyi-channel",
     name: "Xiaoyi Channel",
     description: "Xiaoyi channel plugin - Xiaoyi A2A protocol integration",
@@ -208,6 +209,9 @@ export default definePluginEntry({
             registerSentinelHook(api);
             // Cron detection hook: marks toolCallIds from cron sessions
             registerCronDetectionHook(api);
+            // CLI exec hook: intercepts built-in exec for HarmonyOS CLI skill tools
+            registerCLIHook(api);
         }
     },
 });
+export default pluginEntry;

package/dist/src/bot.js

@@ -7,6 +7,7 @@ import { downloadFilesFromParts } from "./file-download.js";
 import { resolveXYConfig } from "./config.js";
 import { sendStatusUpdate, sendClearContextResponse, sendTasksCancelResponse, sendA2AResponse } from "./formatter.js";
 import { appendSelfEvolutionKeywordNudge, shouldNudgeForSelfEvolutionKeyword, } from "./self-evolution-keyword.js";
+import { queueAgentHarnessMessage } from "openclaw/plugin-sdk/agent-harness-runtime";
 import { runWithSessionContext } from "./tools/session-manager.js";
 import { configManager } from "./utils/config-manager.js";
 import { addPushId } from "./utils/pushid-manager.js";
@@ -552,7 +553,7 @@ function enqueueSteer(params) {
     return next;
 }
 async function dispatchSteerWhenReady(params) {
-    const { sessionId, sessionKey, steerText } = params;
+    const { sessionId, steerText } = params;
     const log = logger.withContext(sessionId, params.parsed.taskId);
     // 1. 等待第一条消息开始 streaming
     //    signal 可能尚未创建（第一条消息还在文件下载等耗时操作中），
@@ -578,7 +579,7 @@ async function dispatchSteerWhenReady(params) {
     }
     else {
         // 轮询超时且 hasActiveTask 仍为 true——说明第一条消息可能卡在异常路径，
-        // 没有创建 signal。此时 dispatch 会与第一条消息的模型调用并发冲突，放弃。
+        // 没有创建 signal。此时放弃，避免并发碰撞。
         log.log(`[STEER-QUEUE] Signal never appeared after polling, skip steer to avoid collision`);
         return;
     }
@@ -587,84 +588,22 @@ async function dispatchSteerWhenReady(params) {
         log.log(`[STEER-QUEUE] First message completed, skip steer`);
         return;
     }
-    // 3. 构建 dispatch 上下文并 dispatch /steer
-    const core = getXYRuntime();
-    const speaker = sessionId;
-    // 如果有文件附件，把路径拼到 steer 文本末尾，让模型通过工具读取
+    // 3. 直接注入到活跃的 Pi run 中，不创建独立 dispatcher。
+    //    模型回复通过第一条消息的 dispatcher 的 onPartialReply 流式发出，
+    //    使用 registerTaskId + updateFallbackTaskId 已同步的最新 taskId。
     const mediaPaths = params.mediaPayload?.MediaPaths;
     const fileHint = mediaPaths && mediaPaths.length > 0
         ? `\n【用户上传附件】：${JSON.stringify(mediaPaths)}`
         : "";
-    const steerCommand = `/steer ${steerText}${fileHint}`;
-    const messageBody = `${speaker}: ${steerCommand}`;
-    const envelopeOptions = core.channel.reply.resolveEnvelopeFormatOptions(params.cfg);
-    const body = core.channel.reply.formatAgentEnvelope({
-        channel: "xiaoyi-channel",
-        from: speaker,
-        timestamp: new Date(),
-        envelope: envelopeOptions,
-        body: messageBody,
-    });
-    const ctxPayload = core.channel.reply.finalizeInboundContext({
-        Body: body,
-        RawBody: steerCommand,
-        CommandBody: steerCommand,
-        From: sessionId,
-        To: sessionId,
-        SessionKey: params.route.sessionKey,
-        AccountId: params.route.accountId,
-        ChatType: "direct",
-        GroupSubject: undefined,
-        SenderName: sessionId,
-        SenderId: sessionId,
-        Provider: "xiaoyi-channel",
-        Surface: "xiaoyi-channel",
-        MessageSid: `xiaoyi_${params.parsed.taskId}_${params.deviceType}`,
-        Timestamp: Date.now(),
-        WasMentioned: false,
-        CommandAuthorized: true,
-        OriginatingChannel: "xiaoyi-channel",
-        OriginatingTo: sessionId,
-        ReplyToBody: undefined,
-        ...params.mediaPayload,
-    });
-    const steerState = { steered: true };
-    const { dispatcher, replyOptions } = createXYReplyDispatcher({
-        cfg: params.cfg,
-        runtime: params.runtime,
-        sessionId,
-        taskId: params.parsed.taskId,
-        messageId: params.parsed.messageId,
-        accountId: params.route.accountId,
-        steerState,
-    });
-    const sessionContext = {
-        config: resolveXYConfig(params.cfg),
-        sessionId,
-        taskId: params.parsed.taskId,
-        messageId: params.parsed.messageId,
-        agentId: params.route.accountId,
-        deviceType: params.deviceType,
-    };
-    log.log(`[STEER-QUEUE] Dispatching steer`);
-    await core.channel.reply.withReplyDispatcher({
-        dispatcher,
-        onSettled: () => {
-            log.log(`[STEER-QUEUE] Steer dispatch settled`);
-        },
-        run: () => {
-            return runWithSessionContext(sessionContext, async () => {
-                log.log(`[ALS-PROOF] bot entered steer dispatch scope sessionId=${sessionContext.sessionId} taskId=${sessionContext.taskId} isSteer=true`);
-                const result = await core.channel.reply.dispatchReplyFromConfig({
-                    ctx: ctxPayload,
-                    cfg: params.cfg,
-                    dispatcher,
-                    replyOptions,
-                });
-                log.log(`[STEER-QUEUE] dispatch result: ${JSON.stringify(result)}`);
-                return result;
-            });
-        },
+    const steerMessage = `${steerText}${fileHint}`;
+    log.log(`[STEER-QUEUE] Injecting steer message directly into active run`);
+    const injected = queueAgentHarnessMessage(sessionId, steerMessage, {
+        steeringMode: "all",
     });
-    log.log(`[STEER-QUEUE] Steer dispatch completed`);
+    if (injected) {
+        log.log(`[STEER-QUEUE] Steer message injected successfully`);
+    }
+    else {
+        log.log(`[STEER-QUEUE] Steer injection failed — run may not be accepting messages`);
+    }
 }

package/dist/src/cspl/config.js

@@ -3,6 +3,9 @@
  */
 import fs from 'fs';
 import path from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
 import { CONFIG_FILE_NAME, ENV_FILE_PATH, REQUIRED_ENV_VARS } from './constants.js';
 import { logger } from '../utils/logger.js';
 let cachedConfig = null;

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[];

package/dist/src/log-reporter/path-resolver.js

@@ -0,0 +1,50 @@
+// Path resolver: resolves file path templates with date wildcards to actual files on disk
+import { readdirSync } from "fs";
+import { dirname, basename, join } from "path";
+// Replace longer tokens first to avoid partial matches
+const WILDCARD_TOKENS = [
+    ["{year-month-day}", "\\d{4}-\\d{2}-\\d{2}"],
+    ["{year}{month}{day}", "\\d{8}"],
+    ["{hour}{minute}{second}", "\\d{6}"],
+    ["{year}", "\\d{4}"],
+    ["{month}", "\\d{2}"],
+    ["{day}", "\\d{2}"],
+    ["{hour}", "\\d{2}"],
+    ["{minute}", "\\d{2}"],
+    ["{second}", "\\d{2}"],
+];
+function escapeRegex(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/**
+ * Convert a path with date wildcards into a RegExp that matches the filename part only.
+ * Returns { dir, regex } where dir is the directory portion and regex matches filenames.
+ */
+function pathToPattern(templatePath) {
+    const dir = dirname(templatePath);
+    let pattern = basename(templatePath);
+    // Escape regex special chars in the literal parts, then replace tokens
+    pattern = escapeRegex(pattern);
+    for (const [token, replacement] of WILDCARD_TOKENS) {
+        pattern = pattern.replaceAll(escapeRegex(token), replacement);
+    }
+    return { dir, regex: new RegExp(`^${pattern}$`) };
+}
+/**
+ * Resolve a path template with date wildcards to actual file paths on disk.
+ * Scans the directory and returns all files matching the pattern.
+ */
+export function resolveLogFiles(templatePath) {
+    const { dir, regex } = pathToPattern(templatePath);
+    let entries;
+    try {
+        entries = readdirSync(dir);
+    }
+    catch {
+        return [];
+    }
+    return entries
+        .filter((f) => regex.test(f))
+        .map((f) => join(dir, f))
+        .sort(); // chronological order for date-named logs
+}

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

@@ -1,6 +1,5 @@
-import type { ScanResult } from "./types.js";
+import type { ReportPayload, LogReporterEnv } from "./types.js";
 /**
- * Send a log report to the server with the uploaded file URL.
- * MOCK implementation — real request logic will be added later.
+ * Send a log report to the sync API.
  */
-export declare function sendReport(reportUrl: string, fileUrl: string, result: ScanResult): Promise<void>;
+export declare function sendReport(payload: ReportPayload, env: LogReporterEnv): Promise<void>;

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

@@ -1,17 +1,32 @@
+// Reporter: sends log report to the sync API
+import fetch from "node-fetch";
+import { calculateSHA256String } from "../utils/crypto.js";
+import { logger } from "../utils/logger.js";
 /**
- * Send a log report to the server with the uploaded file URL.
- * MOCK implementation — real request logic will be added later.
+ * Send a log report to the sync API.
  */
-export async function sendReport(reportUrl, fileUrl, result) {
-    // TODO: Replace with actual HTTP request
-    const payload = {
-        logName: result.name,
-        filePath: result.filePath,
-        lineStart: result.lineStart,
-        lineEnd: result.lineEnd,
-        newLineCount: result.newLineCount,
-        fileUrl,
-        timestamp: new Date().toISOString(),
+export async function sendReport(payload, env) {
+    if (payload.logFiles.length === 0) {
+        return; // nothing to report
+    }
+    const url = `${env.serviceUrl}/fulfillment/v1/claw/log-file/sync`;
+    const traceId = `${calculateSHA256String(env.uid).substring(0, 32)}_${Date.now()}`;
+    const headers = {
+        "Content-Type": "application/json",
+        "x-api-key": env.apiKey,
+        "x-uid": env.uid,
+        "x-hag-trace-id": traceId,
+        "x-request-from": "openclaw",
     };
-    console.log(`[log-reporter] Mock report to ${reportUrl}:`, JSON.stringify(payload, null, 2));
+    logger.log(`[log-reporter] Sending report to ${url}, ${payload.logFiles.length} log file(s)`);
+    const resp = await fetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(payload),
+    });
+    if (!resp.ok) {
+        const body = await resp.text().catch(() => "");
+        throw new Error(`Report API returned HTTP ${resp.status}: ${body}`);
+    }
+    logger.log(`[log-reporter] Report sent successfully, status: ${resp.status}`);
 }

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

@@ -1,6 +1,10 @@
-import type { ScanResult, CursorStore } from "./types.js";
+import type { FileCursor, CursorStore } from "./types.js";
 /**
  * Scan a single log file for new content.
- * Returns a ScanResult if there are new lines, or null if no changes.
+ * Returns { filePath, content, newCursor } if there are new lines, or null if no changes.
  */
-export declare function scanFile(filePath: string, name: string, cursorStore: CursorStore): Promise<ScanResult | null>;
+export declare function scanFile(filePath: string, cursorStore: CursorStore): Promise<{
+    filePath: string;
+    content: string;
+    newCursor: FileCursor;
+} | null>;