@ynhcj/xiaoyi-channel 0.0.209-beta → 0.0.211-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/dist/src/tools/hmos-cli.js

@@ -15,6 +15,7 @@ import path from "path";
 import os from "os";
 import { logger } from "../utils/logger.js";
 import { InvokeError, invokeErrorToResult } from "./invoke.js";
+import { getCurrentSessionContext } from "./session-manager.js";
 import { getXYWebSocketManager } from "../client.js";
 import { sendCommand } from "../formatter.js";
 import { getCurrentTaskId } from "../task-manager.js";
@@ -534,8 +535,8 @@ export async function cliBeforeToolCallHandler(event, ctx) {
             },
         };
     }
-    // Get session context and execute
-    const sessionCtx = (await import("./session-manager.js")).getCurrentSessionContext();
+    // Get session context via ALS (propagated through the async call chain)
+    const sessionCtx = getCurrentSessionContext();
     if (!sessionCtx) {
         logger.warn(`[CLI-HOOK] No session context, blocking (${(performance.now() - t0).toFixed(1)}ms)`);
         return { block: true, blockReason: JSON.stringify({ code: "CONFIG_MISSING", message: "No active session context for CLI execution", retryable: false }) };

package/dist/src/tools/invoke.d.ts

@@ -18,8 +18,6 @@
  *   7. Device executor
  *   8. Invoke tool factory (public API)
  */
-import type { ChannelAgentTool } from "openclaw/plugin-sdk";
-import type { SessionContext } from "./session-manager.js";
 export type InvokeErrorCode = "INVALID_PARAM" | "INVALID_TOOL_DEFINITION" | "CONFIG_MISSING" | "AUTH_FAIL" | "PERMISSION_DENIED" | "CLI_COMMAND_BLOCKED" | "RATE_LIMIT" | "TIMEOUT" | "TOOL_NOT_FOUND" | "TOOL_CONFLICT" | "UNSUPPORTED_PLUGIN_TYPE" | "UNSUPPORTED_PROTOCOL" | "DEVICE_TOOL_BLOCKED" | "UPSTREAM_ERROR" | "NETWORK_ERROR" | "UNKNOWN";
 interface ExecuteResult {
     content: Array<{
@@ -38,11 +36,53 @@ export declare class InvokeError extends Error {
     get status(): number;
 }
 export declare function invokeErrorToResult(error: InvokeError): ExecuteResult;
-/**
- * Create the invoke meta-tool for the given session context.
- *
- * This is the ONLY exported function — the single integration point for
- * create-all-tools.ts.
- */
-export declare function createInvokeTool(ctx: SessionContext): ChannelAgentTool;
+export declare const invokeTool: {
+    name: string;
+    label: string;
+    description: string;
+    parameters: {
+        type: string;
+        properties: {
+            functionName: {
+                type: string;
+                minLength: number;
+                description: string;
+            };
+            funcName: {
+                type: string;
+                minLength: number;
+                description: string;
+            };
+            arguments: {
+                type: string;
+                description: string;
+                properties: {
+                    bundleName: {
+                        type: string;
+                        minLength: number;
+                        description: string;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+            params: {
+                type: string;
+                description: string;
+                properties: {
+                    bundleName: {
+                        type: string;
+                        minLength: number;
+                        description: string;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+        };
+        required: any[];
+        additionalProperties: boolean;
+    };
+    execute(toolCallId: string, rawParams: unknown, _signal?: AbortSignal, _onUpdate?: (partialResult: any) => void): Promise<ExecuteResult>;
+};
 export {};