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

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,6 @@
-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 with retry on failure.
+ * Retries up to 3 times with delays of 10s, 20s, 30s.
  */
-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,56 @@
+// 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";
+/** Retry delays in milliseconds: 10s, 20s, 30s */
+const RETRY_DELAYS_MS = [10000, 20000, 30000];
+const MAX_RETRIES = RETRY_DELAYS_MS.length;
+/** Sleep for a given duration in milliseconds */
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
 /**
- * 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 with retry on failure.
+ * Retries up to 3 times with delays of 10s, 20s, 30s.
  */
-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)`);
+    let lastError;
+    for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+        try {
+            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}`);
+            return; // success, exit
+        }
+        catch (err) {
+            lastError = err instanceof Error ? err : new Error(String(err));
+            if (attempt < MAX_RETRIES) {
+                const delay = RETRY_DELAYS_MS[attempt];
+                logger.warn(`[log-reporter] Report failed (attempt ${attempt + 1}/${MAX_RETRIES + 1}): ${lastError.message}. Retrying in ${delay / 1000}s...`);
+                await sleep(delay);
+            }
+        }
+    }
+    // All retries exhausted
+    throw lastError;
 }

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

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

@@ -1,4 +1,4 @@
-// Core scanner: resolves wildcard paths, reads incremental log content using byte-offset cursors
+// Core scanner: reads incremental log content using byte-offset cursors
 import { statSync, createReadStream } from "fs";
 import { getCursor } from "./cursor-store.js";
 /**
@@ -39,9 +39,9 @@ function resolveStartByte(currentSize, currentMtimeMs, cursor) {
 }
 /**
  * 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 async function scanFile(filePath, name, cursorStore) {
+export async function scanFile(filePath, cursorStore) {
     let stats;
     try {
         stats = statSync(filePath);
@@ -72,11 +72,7 @@ export async function scanFile(filePath, name, cursorStore) {
     };
     return {
         filePath,
-        name,
         content,
-        lineStart: prevLine + 1,
-        lineEnd: prevLine + newLineCount,
-        newLineCount,
         newCursor,
     };
 }

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

@@ -1,20 +1,11 @@
-/** Configuration for a single log file to monitor */
-export interface LogFileConfig {
-    /** File path with optional date wildcards: {year}, {month}, {day}, {year-month-day}, {year}{month}{day} */
+/** Configuration for a single log monitor (hardcoded) */
+export interface LogMonitorConfig {
+    /** File path with date wildcards: {year}, {month}, {day}, {year-month-day}, {year}{month}{day}, {hour}, {minute}, {second} */
     path: string;
-    /** Logical name used in .bak filename and reporting */
-    name: string;
-}
-/** Top-level log reporter configuration (loaded from JSON file) */
-export interface LogReporterConfig {
-    /** Scan interval in milliseconds (default: 600000 = 10 min) */
-    scanIntervalMs: number;
-    /** Directory for .bak files and cursor state */
-    bakDir: string;
-    /** Report server URL (mock for now) */
-    reportUrl: string;
-    /** Log files to monitor */
-    logFiles: LogFileConfig[];
+    /** Business type for reporting */
+    businessType: string;
+    /** Whether to parse JSON log lines (openclaw gateway format) */
+    jsonParse: boolean;
 }
 /** Cursor state for a single log file */
 export interface FileCursor {
@@ -33,23 +24,15 @@ export interface CursorStore {
 export interface ScanResult {
     /** Resolved absolute file path */
     filePath: string;
-    /** Logical name from config */
-    name: string;
-    /** The new log lines (incremental content) */
+    /** Business type from monitor config */
+    businessType: string;
+    /** The new log lines (incremental content, may be parsed/formatted) */
     content: string;
-    /** Start line number (1-based, inclusive) */
-    lineStart: number;
-    /** End line number (1-based, inclusive) */
-    lineEnd: number;
-    /** Number of new lines */
-    newLineCount: number;
     /** Updated cursor to persist after successful upload */
     newCursor: FileCursor;
 }
 /** Options passed to startLogReporter */
 export interface LogReporterOptions {
-    /** Absolute path to the JSON config file */
-    configPath: string;
     /** File upload service instance (from xy_channel) */
     uploadService: UploadService;
 }
@@ -57,3 +40,19 @@ export interface LogReporterOptions {
 export interface UploadService {
     uploadFileAndGetUrl(filePath: string, objectType?: string): Promise<string>;
 }
+/** A single log file entry in the report payload */
+export interface ReportLogFileEntry {
+    businessType: string;
+    fileUrl: string;
+}
+/** Report payload sent to the sync API */
+export interface ReportPayload {
+    instanceId: string;
+    logFiles: ReportLogFileEntry[];
+}
+/** Environment config read from .xiaoyienv */
+export interface LogReporterEnv {
+    serviceUrl: string;
+    apiKey: string;
+    uid: string;
+}

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

@@ -1,6 +1,7 @@
-import type { UploadService, ScanResult } from "./types.js";
+import type { UploadService } from "./types.js";
 /**
- * Write incremental content to .bak file, upload, and return the URL.
+ * Write content to a .bak file, upload, and return the URL.
+ * Retries upload up to 3 times with delays of 10s, 20s, 30s.
  * Cleans up .bak file regardless of success/failure.
  */
-export declare function uploadIncrementalContent(result: ScanResult, bakDir: string, uploadService: UploadService): Promise<string>;
+export declare function uploadContent(content: string, name: string, bakDir: string, uploadService: UploadService): Promise<string>;

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

@@ -1,26 +1,49 @@
-// Uploader: creates .bak file, uploads via XYFileUploadService, cleans up
+// Uploader: creates .bak file, uploads via UploadService, cleans up
 import { writeFileSync, unlinkSync } from "fs";
 import { join } from "path";
 import { mkdirSync } from "fs";
+import { logger } from "../utils/logger.js";
+/** Retry delays in milliseconds: 10s, 20s, 30s */
+const RETRY_DELAYS_MS = [10000, 20000, 30000];
+const MAX_RETRIES = RETRY_DELAYS_MS.length;
+/** Sleep for a given duration in milliseconds */
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
 /**
- * Write incremental content to .bak file, upload, and return the URL.
+ * Write content to a .bak file, upload, and return the URL.
+ * Retries upload up to 3 times with delays of 10s, 20s, 30s.
  * Cleans up .bak file regardless of success/failure.
  */
-export async function uploadIncrementalContent(result, bakDir, uploadService) {
+export async function uploadContent(content, name, bakDir, uploadService) {
     const timestamp = Date.now();
-    const bakFileName = `${result.name}_${timestamp}.bak`;
+    const bakFileName = `${name}_${timestamp}.bak`;
     const bakPath = join(bakDir, bakFileName);
     // Ensure bakDir exists
     try {
         mkdirSync(bakDir, { recursive: true });
     }
     catch { }
+    // Write incremental content to .bak file (only once)
+    writeFileSync(bakPath, content, "utf-8");
+    let lastError;
     try {
-        // Write incremental content to .bak file
-        writeFileSync(bakPath, result.content, "utf-8");
-        // Upload and get URL
-        const url = await uploadService.uploadFileAndGetUrl(bakPath);
-        return url;
+        for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+            try {
+                const url = await uploadService.uploadFileAndGetUrl(bakPath);
+                return url; // success
+            }
+            catch (err) {
+                lastError = err instanceof Error ? err : new Error(String(err));
+                if (attempt < MAX_RETRIES) {
+                    const delay = RETRY_DELAYS_MS[attempt];
+                    logger.warn(`[log-reporter] Upload failed for "${name}" (attempt ${attempt + 1}/${MAX_RETRIES + 1}): ${lastError.message}. Retrying in ${delay / 1000}s...`);
+                    await sleep(delay);
+                }
+            }
+        }
+        // All retries exhausted
+        throw lastError;
     }
     finally {
         // Always clean up the .bak file

package/dist/src/monitor.js

@@ -326,7 +326,6 @@ export async function monitorXYProvider(opts = {}) {
             logger.log("XY gateway: started successfully");
             // Start log reporter (independent periodic scanner + uploader)
             startLogReporter({
-                configPath: "/home/ynhcj/.openclaw/log-reporter-config.json",
                 uploadService: new XYFileUploadService(account.fileUploadUrl, account.apiKey, account.uid),
             }).then((stop) => {
                 stopLogReporter = stop;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ynhcj/xiaoyi-channel",
-  "version": "0.0.209-beta",
+  "version": "0.0.210-beta",
   "description": "OpenClaw Xiaoyi Channel plugin - Xiaoyi A2A protocol integration",
   "type": "module",
   "main": "./dist/index.js",