@ynhcj/xiaoyi-channel 0.0.192-beta → 0.0.192-next

package/dist/src/channel.js

@@ -2,15 +2,55 @@ import { resolveXYConfig, listXYAccountIds, getDefaultXYAccountId } from "./conf
 import { xyConfigSchema } from "./config-schema.js";
 import { xyOutbound } from "./outbound.js";
 import { filterToolsByDevice } from "./tools/device-tool-map.js";
-import { getCurrentSessionContext, registerSession } from "./tools/session-manager.js";
-import { createAllTools } from "./tools/create-all-tools.js";
+import { getCurrentSessionContext } from "./tools/session-manager.js";
 import { logger } from "./utils/logger.js";
-/**
- * Prefix used for synthetic sessionIds created during cron-triggered tool
- * execution.  `sendCommand()` checks this prefix to route commands through
- * the push channel instead of the (non-existent) WebSocket session.
- */
-const CRON_SESSION_PREFIX = "cron-";
+// Static tool imports (3.24 pattern)
+import { locationTool } from "./tools/location-tool.js";
+import { xiaoyiGuiTool } from "./tools/xiaoyi-gui-tool.js";
+import { sendFileToUserTool } from "./tools/send-file-to-user-tool.js";
+import { sendHtmlCardTool } from "./tools/send-html-card-tool.js";
+import { viewPushResultTool } from "./tools/view-push-result-tool.js";
+import { imageReadingTool } from "./tools/image-reading-tool.js";
+import { timestampToUtc8Tool } from "./tools/timestamp-to-utc8-tool.js";
+import { saveSelfEvolutionSkillTool } from "./tools/save-self-evolution-skill-tool.js";
+import { callDeviceTool } from "./tools/call-device-tool.js";
+import { getNoteToolSchemaTool } from "./tools/get-note-tool-schema.js";
+import { getCalendarToolSchemaTool } from "./tools/get-calendar-tool-schema.js";
+import { getContactToolSchemaTool } from "./tools/get-contact-tool-schema.js";
+import { getPhotoToolSchemaTool } from "./tools/get-photo-tool-schema.js";
+import { getDeviceFileToolSchemaTool } from "./tools/get-device-file-tool-schema.js";
+import { getAlarmToolSchemaTool } from "./tools/get-alarm-tool-schema.js";
+import { getCollectionToolSchemaTool } from "./tools/get-collection-tool-schema.js";
+import { loginTokenTool } from "./tools/login-token-tool.js";
+import { agentAsSkillTool } from "./tools/agent-as-skill-tool.js";
+import { discoverCrossDevicesTool } from "./tools/discover-cross-devices-tool.js";
+import { sendCrossDeviceTaskTool } from "./tools/send-cross-device-task-tool.js";
+import { displayA2UICardByPathTool } from "./tools/display-a2ui-card-bypath-tool.js";
+import { checkPluginPrivilegeTool } from "./tools/check-plugin-privilege-tool.js";
+const ALL_TOOLS = [
+    locationTool,
+    discoverCrossDevicesTool,
+    sendCrossDeviceTaskTool,
+    displayA2UICardByPathTool,
+    callDeviceTool,
+    getNoteToolSchemaTool,
+    getCalendarToolSchemaTool,
+    getContactToolSchemaTool,
+    getPhotoToolSchemaTool,
+    xiaoyiGuiTool,
+    getDeviceFileToolSchemaTool,
+    getAlarmToolSchemaTool,
+    getCollectionToolSchemaTool,
+    sendFileToUserTool,
+    sendHtmlCardTool,
+    viewPushResultTool,
+    imageReadingTool,
+    timestampToUtc8Tool,
+    saveSelfEvolutionSkillTool,
+    loginTokenTool,
+    agentAsSkillTool,
+    checkPluginPrivilegeTool,
+];
 /**
  * Xiaoyi Channel Plugin for OpenClaw.
  * Implements Xiaoyi A2A protocol with dual WebSocket connections.
@@ -32,7 +72,7 @@ export const xyPlugin = {
         ],
     },
     capabilities: {
-        chatTypes: ["direct"], // Only private chat (no group support)
+        chatTypes: ["direct"],
         polls: false,
         threads: false,
         media: true,
@@ -49,59 +89,11 @@ export const xyPlugin = {
         schema: xyConfigSchema,
     },
     outbound: xyOutbound,
-    /**
-     * Provide channel-specific agent tools.
-     *
-     * Two execution contexts are supported:
-     *
-     *  1. **Normal (WebSocket) session** – `getCurrentSessionContext()` returns
-     *     a context that was registered by bot.ts during message processing.
-     *     Tools send commands through the WebSocket and listen for responses.
-     *
-     *  2. **Cron / scheduled-task session** – openclaw's cron runner calls
-     *     `agentTools({ cfg })` without an active WebSocket session.  When no
-     *     session context exists but `cfg` is provided, we create a synthetic
-     *     "cron session" with `isCron: true` and a `cron-`-prefixed sessionId.
-     *     `sendCommand()` detects this prefix and routes commands through the
-     *     push channel.  Response listening (WebSocket events) works unchanged
-     *     because the gateway WebSocket connection is always active.
-     */
-    agentTools: (params) => {
-        let ctx = getCurrentSessionContext();
-        // ── Cron / non-session fallback ──────────────────────────────
-        // When no active xy WebSocket session exists but the openclaw cfg
-        // is provided (framework calls agentTools({ cfg })), create a
-        // synthetic "cron session".  This enables cron-triggered agent
-        // turns and cross-channel tool calls to use xiaoyi tools via the
-        // push channel.  sendCommand() detects the "cron-" sessionId
-        // prefix and routes commands through push instead of WebSocket.
-        if (!ctx && params?.cfg) {
-            try {
-                const config = resolveXYConfig(params.cfg);
-                const cronId = `${CRON_SESSION_PREFIX}${Date.now()}-${Math.random().toString(36).substring(2, 8)}`;
-                ctx = {
-                    config,
-                    sessionId: cronId,
-                    taskId: cronId,
-                    messageId: cronId,
-                    agentId: "default",
-                    isCron: true,
-                };
-                // Register so getCurrentSessionContext() fallback can find it
-                registerSession(`__cron__${cronId}`, ctx);
-                logger.log(`[CRON-TOOLS] Created cron session context: ${cronId}`);
-            }
-            catch (err) {
-                logger.error("[CRON-TOOLS] Failed to create cron context:", err);
-            }
-        }
-        if (!ctx) {
-            logger.log("[CREATE-ALL-TOOLS] no session context, returning empty tools list");
-            return [];
-        }
-        const allTools = createAllTools(ctx);
-        const filtered = filterToolsByDevice(allTools, ctx.deviceType);
-        logger.log(`[DEVICE-FILTER] deviceType=${ctx.deviceType ?? "(none)"}, tools: ${allTools.length} → ${filtered.length} (${filtered.map(t => t.name).join(", ")})`);
+    /** Static tool list (3.24 pattern). Tools read SessionContext at execute time via ALS. */
+    agentTools: () => {
+        const ctx = getCurrentSessionContext();
+        const filtered = filterToolsByDevice(ALL_TOOLS, ctx?.deviceType);
+        logger.log(`[DEVICE-FILTER] deviceType=${ctx?.deviceType ?? "(none)"}, tools: ${ALL_TOOLS.length} → ${filtered.length} (${filtered.map(t => t.name).join(", ")})`);
         return filtered;
     },
     messaging: {
@@ -113,7 +105,6 @@ export const xyPlugin = {
         },
         targetResolver: {
             looksLikeId: (raw) => {
-                // 信任所有非空字符串作为有效的 sessionId
                 const trimmed = raw.trim();
                 return trimmed.length > 0;
             },
@@ -135,20 +126,33 @@ export const xyPlugin = {
                 ? { conversationId, matchPriority: 2 }
                 : null;
         },
+        resolveCommandConversation: ({ accountId }) => {
+            // xiaoyi-channel: the A2A sessionId IS the conversationId.
+            // Read from the current ALS session context.
+            const ctx = getCurrentSessionContext();
+            const sessionId = ctx?.sessionId?.trim();
+            if (!sessionId)
+                return null;
+            return { conversationId: sessionId };
+        },
     },
     reload: {
         configPrefixes: ["channels.xiaoyi-channel"],
     },
-    // Gateway adapter for receiving messages
     gateway: {
         async startAccount(context) {
             const { monitorXYProvider } = await import("./monitor.js");
+            const { createXyAcpBindingManager } = await import("./acp-session-binding.js");
             const account = resolveXYConfig(context.cfg);
             context.setStatus?.({
                 accountId: context.accountId,
                 wsUrl: account.wsUrl,
             });
             context.log?.info(`[${context.accountId}] starting xiaoyi channel (wsUrl: ${account.wsUrl})`);
+            // Register ACP session binding adapter for this account.
+            // Enables sessions_spawn(runtime="acp") to bind subagent sessions
+            // to the current A2A conversation.
+            createXyAcpBindingManager({ accountId: context.accountId, cfg: context.cfg });
             return monitorXYProvider({
                 config: context.cfg,
                 runtime: context.runtime,

package/dist/src/client.d.ts

@@ -1,6 +1,11 @@
 import { XYWebSocketManager } from "./websocket.js";
 import type { XYChannelConfig } from "./types.js";
 import type { RuntimeEnv } from "openclaw/plugin-sdk";
+/**
+ * Get a cached WebSocket manager without requiring config.
+ * Returns the first available manager. Use when ALS has no SessionContext.
+ */
+export declare function getCachedXYWebSocketManager(): XYWebSocketManager;
 /**
  * Get or create a WebSocket manager for the given configuration.
  * Reuses existing managers if config matches.

package/dist/src/client.js

@@ -13,6 +13,16 @@ if (!_g.__xyWsManagerCache) {
     _g.__xyWsManagerCache = new Map();
 }
 const wsManagerCache = _g.__xyWsManagerCache;
+/**
+ * Get a cached WebSocket manager without requiring config.
+ * Returns the first available manager. Use when ALS has no SessionContext.
+ */
+export function getCachedXYWebSocketManager() {
+    if (wsManagerCache.size === 0) {
+        throw new Error("No WebSocket manager available in cache");
+    }
+    return wsManagerCache.values().next().value;
+}
 /**
  * Get or create a WebSocket manager for the given configuration.
  * Reuses existing managers if config matches.

package/dist/src/cspl/call_api.js

@@ -5,6 +5,7 @@ import https from 'https';
 import { URL } from 'url';
 import { getConfig } from './config.js';
 import { DEFAULT_HTTPS_PORT, HTTP_STATUS_BAD_REQUEST, API_URL_SUFFIX } from './constants.js';
+import { logger } from '../utils/logger.js';
 function buildHeadersForCelia(config, sessionId) {
     if (!config.uid || !config.apiKey || !config.skillId || !config.requestFrom) {
         throw new Error('[SENTINEL HOOK] Missing required configuration: uid, apiKey, skillId, or requestFrom is not defined');
@@ -89,6 +90,7 @@ export async function callApi(questionText, api, sessionId, action) {
     };
     const httpBody = JSON.stringify(payload);
     const apiUrl = `${config.api.url}${API_URL_SUFFIX}`;
+    logger.log(`[SENTINEL HOOK] callApi: action=${action}, x-hag-trace-id=${sessionId}, url=${apiUrl}`);
     return new Promise((resolve, reject) => {
         const options = buildRequestOptions(apiUrl, headersForCelia, config.api.timeout);
         const req = https.request(options, (res) => {

package/dist/src/cspl/sentinel_hook.js

@@ -6,15 +6,16 @@ import { callApi } from './call_api.js';
 import { processText, extractResultText, validateAndTruncateText, parseSecurityResult, handleExecToolInput, handleMessageToolInput, handleOtherToolInput } from './utils.js';
 import { ALLOWED_TOOLS, MAX_TEXT_LENGTH, MAX_TOTAL_LENGTH, MIN_TEXT_LENGTH, STEER_ABORT_MESSAGE, TOOL_OUTPUT_ACTION } from './constants.js';
 import { logger } from '../utils/logger.js';
-import { getSessionContext } from '../tools/session-manager.js';
+import { getCurrentSessionContext } from '../tools/session-manager.js';
 import { tryInjectSteer } from './steer-context.js';
 // 主入口模块
 export default function register(api) {
     api.on("before_tool_call", async (event, ctx) => {
         logger.log(`[SENTINEL HOOK] before_tool_call_event toolName: ${event.toolName}`);
-        // 生成sessionID
-        const sessionId = (event.runId?.replace(/-/g, '') || crypto.randomBytes(16).toString('hex'));
-        logger.log(`[SENTINEL HOOK] Generated Session ID: ${sessionId}`);
+        // 获取真实sessionID：优先使用ALS中的A2A sessionId，降级到OpenClaw runId或随机值
+        const sessionCtx = getCurrentSessionContext();
+        const sessionId = sessionCtx?.sessionId || (event.runId?.replace(/-/g, '') || crypto.randomBytes(16).toString('hex'));
+        logger.log(`[SENTINEL HOOK] Session ID: ${sessionId} (fromALS: ${!!sessionCtx?.sessionId})`);
         // 处理 TOOL_INPUT 数据采集、发送数据，根据扫描结果决定是否阻塞
         try {
             let scanResult = null;
@@ -43,9 +44,10 @@ export default function register(api) {
         }
         try {
             logger.log(`[SENTINEL HOOK] after_tool_call_event toolName: ${event.toolName}`);
-            // 生成sessionID
-            const sessionId = (event.runId?.replace(/-/g, '') || crypto.randomBytes(16).toString('hex'));
-            logger.log(`[SENTINEL HOOK] Generated Session ID: ${sessionId}`);
+            // 获取真实sessionID：优先使用ALS中的A2A sessionId，降级到OpenClaw runId或随机值
+            const sessionCtx = getCurrentSessionContext();
+            const sessionId = sessionCtx?.sessionId || (event.runId?.replace(/-/g, '') || crypto.randomBytes(16).toString('hex'));
+            logger.log(`[SENTINEL HOOK] Session ID: ${sessionId} (fromALS: ${!!sessionCtx?.sessionId})`);
             // 处理TOOL_OUTPUT数据采集（保持现有逻辑）
             const resultText = extractResultText(event, event.toolName);
             const resultTextLength = resultText.length;
@@ -78,7 +80,6 @@ export default function register(api) {
                 logger.log(`[SENTINEL HOOK] TOOL_OUTPUT response: status=${result.status}.`);
                 if (result.status === 'REJECT') {
                     logger.warn('[SENTINEL HOOK] REJECT detected, attempting steer injection');
-                    const sessionCtx = ctx.sessionKey ? getSessionContext(ctx.sessionKey) : null;
                     if (sessionCtx?.sessionId && sessionCtx?.taskId) {
                         await tryInjectSteer({
                             sessionId: sessionCtx.sessionId,

package/dist/src/formatter.d.ts

@@ -10,6 +10,9 @@ export interface SendA2AResponseParams {
     text?: string;
     append: boolean;
     final: boolean;
+    /** Optional: reuse an existing artifactId instead of generating a new one.
+     *  Used by subagent completion to link results to the original artifact. */
+    artifactId?: string;
     files?: Array<{
         fileName: string;
         fileType: string;
@@ -50,6 +53,8 @@ export interface SendStatusUpdateParams {
     messageId: string;
     text: string;
     state: "submitted" | "working" | "input-required" | "completed" | "canceled" | "failed" | "unknown";
+    /** When false, use the exact taskId/messageId passed in. Default true (dynamic lookup). */
+    useLatestTask?: boolean;
 }
 /**
  * Send an A2A task status update.

package/dist/src/formatter.js

@@ -1,8 +1,8 @@
 // OpenClaw → A2A format conversion
+import os from "os";
 import { v4 as uuidv4 } from "uuid";
 import { getXYWebSocketManager } from "./client.js";
 import { logger } from "./utils/logger.js";
-import { getCurrentTaskId, getCurrentMessageId } from "./task-manager.js";
 import { redactSensitiveText, containsSensitiveInfo } from "./sensitive-redactor.js";
 import { rewriteOutboundApprovalText } from "./approval-bridge.js";
 import { isCronToolCall, getCurrentCronJobId } from "./tools/session-manager.js";
@@ -45,7 +45,7 @@ function buildTextPreview(text) {
  * Send an A2A artifact update response.
  */
 export async function sendA2AResponse(params) {
-    const { config, sessionId, taskId, messageId, text, append, final, files, errorCode, errorMessage, log: shouldLog = true } = params;
+    const { config, sessionId, taskId, messageId, text, append, final, artifactId, files, errorCode, errorMessage, log: shouldLog = true } = params;
     const log = logger.withContext(sessionId, taskId);
     // 审批桥接：将 OpenClaw 的审批提示翻译成用户友好的确认文案
     const bridgedText = text === undefined ? text : rewriteOutboundApprovalText(sessionId, text);
@@ -57,7 +57,7 @@ export async function sendA2AResponse(params) {
         lastChunk: true,
         final,
         artifact: {
-            artifactId: uuidv4(),
+            artifactId: artifactId ?? uuidv4(),
             parts: [],
         },
     };
@@ -98,7 +98,7 @@ export async function sendA2AResponse(params) {
         agentId: config.agentId,
         sessionId,
         taskId,
-        msgDetail: JSON.stringify(jsonRpcResponse),
+        msgDetail: JSON.stringify({ ...jsonRpcResponse, hostname: os.hostname() }),
     };
     if (shouldLog) {
         const redactedText = redactSensitiveText(bridgedText ?? "");
@@ -148,7 +148,7 @@ export async function sendReasoningTextUpdate(params) {
         agentId: config.agentId,
         sessionId,
         taskId,
-        msgDetail: JSON.stringify(jsonRpcResponse),
+        msgDetail: JSON.stringify({ ...jsonRpcResponse, hostname: os.hostname() }),
     };
     await wsManager.sendMessage(sessionId, outboundMessage);
 }
@@ -157,12 +157,8 @@ export async function sendReasoningTextUpdate(params) {
  * Follows A2A protocol standard format with nested status object.
  */
 export async function sendStatusUpdate(params) {
-    const { config, sessionId, taskId, messageId, text, state } = params;
-    // Dynamic lookup: use latest taskId/messageId from task-manager (handles steer/interrupt),
-    // fall back to closure-captured values
-    const currentTaskId = getCurrentTaskId(sessionId) ?? taskId;
-    const currentMessageId = getCurrentMessageId(sessionId) ?? messageId;
-    const log = logger.withContext(sessionId, currentTaskId);
+    const { config, sessionId, taskId, messageId, text, state, useLatestTask = true } = params;
+    const log = logger.withContext(sessionId, taskId);
     // 审批桥接和脱敏
     const bridgedText = rewriteOutboundApprovalText(sessionId, text);
     const redactedText = redactSensitiveText(bridgedText);
@@ -177,7 +173,7 @@ export async function sendStatusUpdate(params) {
         ],
     });
     const statusUpdate = {
-        taskId: currentTaskId,
+        taskId,
         kind: "status-update",
         final: false, // Status updates should not end the stream
         status: {
@@ -188,7 +184,7 @@ export async function sendStatusUpdate(params) {
     // Build JSON-RPC response
     const jsonRpcResponse = {
         jsonrpc: "2.0",
-        id: currentMessageId,
+        id: messageId,
         result: statusUpdate,
     };
     // Send via WebSocket
@@ -197,8 +193,8 @@ export async function sendStatusUpdate(params) {
         msgType: "agent_response",
         agentId: config.agentId,
         sessionId,
-        taskId: currentTaskId,
-        msgDetail: JSON.stringify(jsonRpcResponse),
+        taskId,
+        msgDetail: JSON.stringify({ ...jsonRpcResponse, hostname: os.hostname() }),
     };
     // Log complete response body
     log.log(`[A2A_STATUS] Sending status-update, text="${redactedText}"`);
@@ -270,15 +266,11 @@ export async function sendCommand(params) {
         return sendCommandViaPush({ config, command: commands[0], pushId });
     }
     // ── Normal mode: WebSocket ─────────────────────────────────────
-    // Dynamic lookup: use latest taskId/messageId from task-manager (handles steer/interrupt),
-    // fall back to closure-captured values
-    const currentTaskId = getCurrentTaskId(sessionId) ?? taskId;
-    const currentMessageId = getCurrentMessageId(sessionId) ?? messageId;
-    const log = logger.withContext(sessionId, currentTaskId);
+    const log = logger.withContext(sessionId, taskId);
     // Build artifact update with command as data
     // Wrap command in commands array as per protocol requirement
     const artifact = {
-        taskId: currentTaskId,
+        taskId,
         kind: "artifact-update",
         append: false,
         lastChunk: true,
@@ -300,7 +292,7 @@ export async function sendCommand(params) {
     // Build JSON-RPC response
     const jsonRpcResponse = {
         jsonrpc: "2.0",
-        id: currentMessageId,
+        id: messageId,
         result: artifact,
     };
     // Send via WebSocket
@@ -309,8 +301,8 @@ export async function sendCommand(params) {
         msgType: "agent_response",
         agentId: config.agentId,
         sessionId,
-        taskId: currentTaskId,
-        msgDetail: JSON.stringify(jsonRpcResponse),
+        taskId,
+        msgDetail: JSON.stringify({ ...jsonRpcResponse, hostname: os.hostname() }),
     };
     // Log complete response body
     log.log(`[A2A_COMMAND] Sending command`);
@@ -329,12 +321,10 @@ export async function sendCard(params) {
         throw new Error("sendCard does not support cron mode");
     }
     // ── Normal mode: WebSocket ─────────────────────────────────────
-    const currentTaskId = getCurrentTaskId(sessionId) ?? taskId;
-    const currentMessageId = getCurrentMessageId(sessionId) ?? messageId;
-    const log = logger.withContext(sessionId, currentTaskId);
+    const log = logger.withContext(sessionId, taskId);
     // Build artifact update with cardsInfo as data
     const artifact = {
-        taskId: currentTaskId,
+        taskId,
         kind: "artifact-update",
         append: false,
         lastChunk: true,
@@ -354,7 +344,7 @@ export async function sendCard(params) {
     // Build JSON-RPC response
     const jsonRpcResponse = {
         jsonrpc: "2.0",
-        id: currentMessageId,
+        id: messageId,
         result: artifact,
     };
     // Send via WebSocket
@@ -363,8 +353,8 @@ export async function sendCard(params) {
         msgType: "agent_response",
         agentId: config.agentId,
         sessionId,
-        taskId: currentTaskId,
-        msgDetail: JSON.stringify(jsonRpcResponse),
+        taskId,
+        msgDetail: JSON.stringify({ ...jsonRpcResponse, hostname: os.hostname() }),
     };
     log.log(`[A2A_CARD] Sending card`);
     await wsManager.sendMessage(sessionId, outboundMessage);
@@ -398,7 +388,7 @@ export async function sendClearContextResponse(params) {
         agentId: config.agentId,
         sessionId,
         taskId: sessionId, // Use sessionId as taskId for clearContext
-        msgDetail: JSON.stringify(jsonRpcResponse),
+        msgDetail: JSON.stringify({ ...jsonRpcResponse, hostname: os.hostname() }),
     };
     await wsManager.sendMessage(sessionId, outboundMessage);
     log.log(`[CLEAR_CONTEXT] Sent clearContext response`);
@@ -432,7 +422,7 @@ export async function sendTasksCancelResponse(params) {
         agentId: config.agentId,
         sessionId,
         taskId,
-        msgDetail: JSON.stringify(jsonRpcResponse),
+        msgDetail: JSON.stringify({ ...jsonRpcResponse, hostname: os.hostname() }),
     };
     await wsManager.sendMessage(sessionId, outboundMessage);
     log.log(`[TASKS_CANCEL] Sent tasks/cancel response`);
@@ -480,7 +470,7 @@ export async function sendTriggerResponse(params) {
         agentId: config.agentId,
         sessionId,
         taskId,
-        msgDetail: JSON.stringify(jsonRpcResponse),
+        msgDetail: JSON.stringify({ ...jsonRpcResponse, hostname: os.hostname() }),
     };
     log.log(`[TRIGGER_RESPONSE] Sending Trigger response, text=${buildTextPreview(redactedContent)}`);
     await wsManager.sendMessage(sessionId, outboundMessage);

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

@@ -0,0 +1,11 @@
+import type { LogReporterConfig } from "./types.js";
+/**
+ * Load and validate the JSON config file.
+ * Falls back to defaults for optional fields.
+ */
+export declare function loadConfig(configPath: string): LogReporterConfig;
+/**
+ * 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/config-loader.js

@@ -0,0 +1,68 @@
+// Config loader: reads JSON config file, validates fields, resolves date wildcards to actual files
+import { readFileSync, 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}"],
+    ["{year}", "\\d{4}"],
+    ["{month}", "\\d{2}"],
+    ["{day}", "\\d{2}"],
+];
+/**
+ * Load and validate the JSON config file.
+ * Falls back to defaults for optional fields.
+ */
+export function loadConfig(configPath) {
+    const raw = readFileSync(configPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!parsed.logFiles || !Array.isArray(parsed.logFiles) || parsed.logFiles.length === 0) {
+        throw new Error("log-reporter config: 'logFiles' must be a non-empty array");
+    }
+    for (const lf of parsed.logFiles) {
+        if (!lf.path || !lf.name) {
+            throw new Error(`log-reporter config: each logFile must have 'path' and 'name', got ${JSON.stringify(lf)}`);
+        }
+    }
+    return {
+        scanIntervalMs: parsed.scanIntervalMs ?? 600000,
+        bakDir: parsed.bakDir ?? "/tmp/openclaw",
+        reportUrl: parsed.reportUrl ?? "",
+        logFiles: parsed.logFiles,
+    };
+}
+/**
+ * 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}$`) };
+}
+function escapeRegex(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/**
+ * 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/cursor-store.d.ts

@@ -0,0 +1,5 @@
+import type { CursorStore, FileCursor } from "./types.js";
+export declare function loadCursorStore(storePath: string): CursorStore;
+export declare function saveCursorStore(storePath: string, store: CursorStore): void;
+export declare function getCursor(store: CursorStore, filePath: string): FileCursor | undefined;
+export declare function setCursor(store: CursorStore, filePath: string, cursor: FileCursor): void;

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

@@ -0,0 +1,26 @@
+// Cursor state persistence — reads/writes FileCursor entries keyed by file path
+import { readFileSync, writeFileSync, mkdirSync } from "fs";
+import { dirname } from "path";
+export function loadCursorStore(storePath) {
+    try {
+        const raw = readFileSync(storePath, "utf-8");
+        const parsed = JSON.parse(raw);
+        return { files: parsed.files ?? {} };
+    }
+    catch {
+        return { files: {} };
+    }
+}
+export function saveCursorStore(storePath, store) {
+    try {
+        mkdirSync(dirname(storePath), { recursive: true });
+    }
+    catch { }
+    writeFileSync(storePath, JSON.stringify(store, null, 2), "utf-8");
+}
+export function getCursor(store, filePath) {
+    return store.files[filePath];
+}
+export function setCursor(store, filePath, cursor) {
+    store.files[filePath] = cursor;
+}

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

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