@ynhcj/xiaoyi-channel 0.0.170-next → 0.0.171-next

package/dist/src/acp-session-binding.d.ts

@@ -0,0 +1,37 @@
+import { type BindingTargetKind } from "openclaw/plugin-sdk/conversation-runtime";
+type XyBindingTargetKind = "subagent" | "acp";
+type XyAcpBindingRecord = {
+    accountId: string;
+    conversationId: string;
+    parentConversationId?: string;
+    deliveryTo?: string;
+    targetKind: XyBindingTargetKind;
+    targetSessionKey: string;
+    agentId?: string;
+    label?: string;
+    boundBy?: string;
+    boundAt: number;
+    lastActivityAt: number;
+};
+type XyAcpBindingManager = {
+    accountId: string;
+    getByConversationId: (conversationId: string) => XyAcpBindingRecord | undefined;
+    listBySessionKey: (targetSessionKey: string) => XyAcpBindingRecord[];
+    bindConversation: (params: {
+        conversationId: string;
+        parentConversationId?: string;
+        targetKind: BindingTargetKind;
+        targetSessionKey: string;
+        metadata?: Record<string, unknown>;
+    }) => XyAcpBindingRecord | null;
+    touchConversation: (conversationId: string, at?: number) => XyAcpBindingRecord | null;
+    unbindConversation: (conversationId: string) => XyAcpBindingRecord | null;
+    unbindBySessionKey: (targetSessionKey: string) => XyAcpBindingRecord[];
+    stop: () => void;
+};
+export declare function createXyAcpBindingManager(params: {
+    accountId?: string;
+    cfg: any;
+}): XyAcpBindingManager;
+export declare function getXyAcpBindingManager(accountId?: string): XyAcpBindingManager | null;
+export {};

package/dist/src/acp-session-binding.js

@@ -0,0 +1,237 @@
+// ACP Session Binding Adapter for xiaoyi-channel.
+// Follows the feishu thread-bindings.ts pattern.
+//
+// Maps A2A sessionId (stable conversation identifier) to ACP/subagent
+// session keys so that openclaw can bind spawned sessions to the
+// current xiaoyi conversation.
+//
+// Key design: xiaoyi-channel only supports `placement: "current"` —
+// it cannot create child threads (unlike Discord). All spawned sessions
+// are bound to the current A2A conversation identified by sessionId.
+// NOTE: Using `any` for cfg type to avoid version mismatch between
+// local and global openclaw installs (auth.profiles.aws-sdk union).
+import { resolveThreadBindingIdleTimeoutMsForChannel, resolveThreadBindingMaxAgeMsForChannel, resolveThreadBindingConversationIdFromBindingId, registerSessionBindingAdapter, unregisterSessionBindingAdapter, } from "openclaw/plugin-sdk/conversation-runtime";
+import { normalizeAccountId, resolveAgentIdFromSessionKey } from "openclaw/plugin-sdk/routing";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { logger } from "./utils/logger.js";
+// ─── Global state (survives module dedup) ─────────────────────
+const XY_ACP_BINDINGS_KEY = Symbol.for("openclaw.xyAcpBindingsState");
+let state;
+function getState() {
+    if (!state) {
+        const globalStore = globalThis;
+        state = globalStore[XY_ACP_BINDINGS_KEY] ?? {
+            managersByAccountId: new Map(),
+            bindingsByAccountConversation: new Map(),
+        };
+        globalStore[XY_ACP_BINDINGS_KEY] = state;
+    }
+    return state;
+}
+function resolveBindingKey(params) {
+    return `${params.accountId}:${params.conversationId}`;
+}
+// ─── Kind conversion ──────────────────────────────────────────
+function toSessionBindingTargetKind(raw) {
+    return raw === "subagent" ? "subagent" : "session";
+}
+function toXyTargetKind(raw) {
+    return raw === "subagent" ? "subagent" : "acp";
+}
+// ─── Record conversion ────────────────────────────────────────
+function toSessionBindingRecord(record, defaults) {
+    const idleExpiresAt = defaults.idleTimeoutMs > 0 ? record.lastActivityAt + defaults.idleTimeoutMs : undefined;
+    const maxAgeExpiresAt = defaults.maxAgeMs > 0 ? record.boundAt + defaults.maxAgeMs : undefined;
+    const expiresAt = idleExpiresAt != null && maxAgeExpiresAt != null
+        ? Math.min(idleExpiresAt, maxAgeExpiresAt)
+        : (idleExpiresAt ?? maxAgeExpiresAt);
+    return {
+        bindingId: resolveBindingKey({
+            accountId: record.accountId,
+            conversationId: record.conversationId,
+        }),
+        targetSessionKey: record.targetSessionKey,
+        targetKind: toSessionBindingTargetKind(record.targetKind),
+        conversation: {
+            channel: "xiaoyi-channel",
+            accountId: record.accountId,
+            conversationId: record.conversationId,
+            parentConversationId: record.parentConversationId,
+        },
+        status: "active",
+        boundAt: record.boundAt,
+        expiresAt,
+        metadata: {
+            agentId: record.agentId,
+            label: record.label,
+            boundBy: record.boundBy,
+            deliveryTo: record.deliveryTo,
+            lastActivityAt: record.lastActivityAt,
+            idleTimeoutMs: defaults.idleTimeoutMs,
+            maxAgeMs: defaults.maxAgeMs,
+        },
+    };
+}
+// ─── Manager factory ──────────────────────────────────────────
+export function createXyAcpBindingManager(params) {
+    const accountId = normalizeAccountId(params.accountId);
+    const existing = getState().managersByAccountId.get(accountId);
+    if (existing) {
+        return existing;
+    }
+    const idleTimeoutMs = resolveThreadBindingIdleTimeoutMsForChannel({
+        cfg: params.cfg,
+        channel: "xiaoyi-channel",
+        accountId,
+    });
+    const maxAgeMs = resolveThreadBindingMaxAgeMsForChannel({
+        cfg: params.cfg,
+        channel: "xiaoyi-channel",
+        accountId,
+    });
+    const log = logger.withContext("", "");
+    const manager = {
+        accountId,
+        getByConversationId: (conversationId) => getState().bindingsByAccountConversation.get(resolveBindingKey({ accountId, conversationId })),
+        listBySessionKey: (targetSessionKey) => [...getState().bindingsByAccountConversation.values()].filter((record) => record.accountId === accountId && record.targetSessionKey === targetSessionKey),
+        bindConversation: ({ conversationId, parentConversationId, targetKind, targetSessionKey, metadata, }) => {
+            const normalizedConversationId = conversationId.trim();
+            const normalizedTargetSessionKey = targetSessionKey.trim();
+            if (!normalizedConversationId || !normalizedTargetSessionKey) {
+                return null;
+            }
+            const existingLocal = getState().bindingsByAccountConversation.get(resolveBindingKey({ accountId, conversationId: normalizedConversationId }));
+            const now = Date.now();
+            const record = {
+                accountId,
+                conversationId: normalizedConversationId,
+                parentConversationId: normalizeOptionalString(parentConversationId) ?? existingLocal?.parentConversationId,
+                deliveryTo: typeof metadata?.deliveryTo === "string" && metadata.deliveryTo.trim()
+                    ? metadata.deliveryTo.trim()
+                    : existingLocal?.deliveryTo,
+                targetKind: toXyTargetKind(targetKind),
+                targetSessionKey: normalizedTargetSessionKey,
+                agentId: typeof metadata?.agentId === "string" && metadata.agentId.trim()
+                    ? metadata.agentId.trim()
+                    : (existingLocal?.agentId ?? resolveAgentIdFromSessionKey(normalizedTargetSessionKey)),
+                label: typeof metadata?.label === "string" && metadata.label.trim()
+                    ? metadata.label.trim()
+                    : existingLocal?.label,
+                boundBy: typeof metadata?.boundBy === "string" && metadata.boundBy.trim()
+                    ? metadata.boundBy.trim()
+                    : existingLocal?.boundBy,
+                boundAt: now,
+                lastActivityAt: now,
+            };
+            getState().bindingsByAccountConversation.set(resolveBindingKey({ accountId, conversationId: normalizedConversationId }), record);
+            log.log(`[XY-ACP-BIND] Bound ${targetKind} session ${normalizedTargetSessionKey.slice(0, 30)} to conversation ${normalizedConversationId.slice(0, 12)}`);
+            return record;
+        },
+        touchConversation: (conversationId, at = Date.now()) => {
+            const key = resolveBindingKey({ accountId, conversationId });
+            const existingRecord = getState().bindingsByAccountConversation.get(key);
+            if (!existingRecord) {
+                return null;
+            }
+            const updated = { ...existingRecord, lastActivityAt: at };
+            getState().bindingsByAccountConversation.set(key, updated);
+            return updated;
+        },
+        unbindConversation: (conversationId) => {
+            const key = resolveBindingKey({ accountId, conversationId });
+            const existingRecord = getState().bindingsByAccountConversation.get(key);
+            if (!existingRecord) {
+                return null;
+            }
+            getState().bindingsByAccountConversation.delete(key);
+            return existingRecord;
+        },
+        unbindBySessionKey: (targetSessionKey) => {
+            const removed = [];
+            for (const record of getState().bindingsByAccountConversation.values()) {
+                if (record.accountId !== accountId || record.targetSessionKey !== targetSessionKey) {
+                    continue;
+                }
+                getState().bindingsByAccountConversation.delete(resolveBindingKey({ accountId, conversationId: record.conversationId }));
+                removed.push(record);
+            }
+            return removed;
+        },
+        stop: () => {
+            for (const key of getState().bindingsByAccountConversation.keys()) {
+                if (key.startsWith(`${accountId}:`)) {
+                    getState().bindingsByAccountConversation.delete(key);
+                }
+            }
+            getState().managersByAccountId.delete(accountId);
+            unregisterSessionBindingAdapter({
+                channel: "xiaoyi-channel",
+                accountId,
+                adapter: sessionBindingAdapter,
+            });
+            log.log(`[XY-ACP-BIND] Stopped binding manager for account ${accountId}`);
+        },
+    };
+    const sessionBindingAdapter = {
+        channel: "xiaoyi-channel",
+        accountId,
+        capabilities: {
+            placements: ["current"],
+        },
+        bind: async (input) => {
+            if (input.conversation.channel !== "xiaoyi-channel" || input.placement === "child") {
+                return null;
+            }
+            const bound = manager.bindConversation({
+                conversationId: input.conversation.conversationId,
+                parentConversationId: input.conversation.parentConversationId,
+                targetKind: input.targetKind,
+                targetSessionKey: input.targetSessionKey,
+                metadata: input.metadata,
+            });
+            return bound ? toSessionBindingRecord(bound, { idleTimeoutMs, maxAgeMs }) : null;
+        },
+        listBySession: (targetSessionKey) => manager
+            .listBySessionKey(targetSessionKey)
+            .map((entry) => toSessionBindingRecord(entry, { idleTimeoutMs, maxAgeMs })),
+        resolveByConversation: (ref) => {
+            if (ref.channel !== "xiaoyi-channel") {
+                return null;
+            }
+            const found = manager.getByConversationId(ref.conversationId);
+            return found ? toSessionBindingRecord(found, { idleTimeoutMs, maxAgeMs }) : null;
+        },
+        touch: (bindingId, at) => {
+            const conversationId = resolveThreadBindingConversationIdFromBindingId({
+                accountId,
+                bindingId,
+            });
+            if (conversationId) {
+                manager.touchConversation(conversationId, at);
+            }
+        },
+        unbind: async (input) => {
+            if (input.targetSessionKey?.trim()) {
+                return manager
+                    .unbindBySessionKey(input.targetSessionKey.trim())
+                    .map((entry) => toSessionBindingRecord(entry, { idleTimeoutMs, maxAgeMs }));
+            }
+            const conversationId = resolveThreadBindingConversationIdFromBindingId({
+                accountId,
+                bindingId: input.bindingId,
+            });
+            if (!conversationId) {
+                return [];
+            }
+            const removed = manager.unbindConversation(conversationId);
+            return removed ? [toSessionBindingRecord(removed, { idleTimeoutMs, maxAgeMs })] : [];
+        },
+    };
+    registerSessionBindingAdapter(sessionBindingAdapter);
+    getState().managersByAccountId.set(accountId, manager);
+    log.log(`[XY-ACP-BIND] Created binding manager for account ${accountId} (idleTimeout=${idleTimeoutMs}ms, maxAge=${maxAgeMs}ms)`);
+    return manager;
+}
+export function getXyAcpBindingManager(accountId) {
+    return getState().managersByAccountId.get(normalizeAccountId(accountId)) ?? null;
+}

package/dist/src/bot.js

@@ -1,7 +1,7 @@
 import { updateSessionStoreEntry, updateSessionStore, resolveStorePath } from "openclaw/plugin-sdk/session-store-runtime";
 import { getXYRuntime } from "./runtime.js";
 import { createXYReplyDispatcher } from "./reply-dispatcher.js";
-import { parseA2AMessage, extractTextFromParts, extractFileParts, extractPushId, extractDeviceType, extractModelName, extractTriggerData, extractRunCrossTaskContext } from "./parser.js";
+import { parseA2AMessage, extractTextFromParts, extractFileParts, extractPushId, extractDeviceType, extractAppVer, extractDisplayVersion, extractModelName, extractTriggerData, extractRunCrossTaskContext } from "./parser.js";
 import { downloadFilesFromParts } from "./file-download.js";
 import { resolveXYConfig } from "./config.js";
 import { sendStatusUpdate, sendClearContextResponse, sendTasksCancelResponse, sendA2AResponse } from "./formatter.js";
@@ -139,6 +139,15 @@ export async function handleXYMessage(params) {
         if (deviceType) {
             log.log(`[BOT] Extracted deviceType: ${deviceType}`);
         }
+        // Extract app_ver and display_version if present
+        const appVer = extractAppVer(parsed.parts);
+        if (appVer) {
+            log.log(`[BOT] Extracted app_ver: ${appVer}`);
+        }
+        const displayVersion = extractDisplayVersion(parsed.parts);
+        if (displayVersion) {
+            log.log(`[BOT] Extracted display_version: ${displayVersion}`);
+        }
         // Extract modelName if present (used by provider.ts to override model.id)
         const modelName = extractModelName(parsed.parts);
         if (modelName) {

package/dist/src/channel.js

@@ -133,12 +133,17 @@ export const xyPlugin = {
     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/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

@@ -12,9 +12,10 @@ 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 = getCurrentSessionContext();
                     if (sessionCtx?.sessionId && sessionCtx?.taskId) {
                         await tryInjectSteer({
                             sessionId: sessionCtx.sessionId,

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;

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

@@ -0,0 +1,77 @@
+// Log Reporter Framework
+// Self-contained periodic log scanner + uploader + reporter.
+// Start via startLogReporter(), stop via stopLogReporter().
+import { resolveLogFiles, loadConfig } from "./config-loader.js";
+import { scanFile } from "./scanner.js";
+import { uploadIncrementalContent } from "./uploader.js";
+import { sendReport } from "./reporter.js";
+import { loadCursorStore, saveCursorStore, setCursor } from "./cursor-store.js";
+import { join } from "path";
+let intervalId = null;
+let isRunning = false;
+/**
+ * Start the log reporter. Runs the first scan immediately, then on the configured 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`);
+    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)`);
+                for (const filePath of resolvedFiles) {
+                    await processFile(filePath, logFile.name, config, cursorStore, options);
+                }
+            }
+            saveCursorStore(cursorPath, cursorStore);
+        }
+        catch (err) {
+            console.error("[log-reporter] Scan failed:", err);
+        }
+        finally {
+            isRunning = false;
+        }
+    }
+    // Run first scan immediately
+    await doScan();
+    // Schedule periodic scans
+    intervalId = setInterval(doScan, config.scanIntervalMs);
+    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.
+ */
+export function stopLogReporter() {
+    if (intervalId !== null) {
+        clearInterval(intervalId);
+        intervalId = null;
+        console.log("[log-reporter] Stopped");
+    }
+}

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

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

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

@@ -0,0 +1,17 @@
+/**
+ * Send a log report to the server with the uploaded file URL.
+ * MOCK implementation — real request logic will be added later.
+ */
+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(),
+    };
+    console.log(`[log-reporter] Mock report to ${reportUrl}:`, JSON.stringify(payload, null, 2));
+}

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

@@ -0,0 +1,6 @@
+import type { ScanResult, 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.
+ */
+export declare function scanFile(filePath: string, name: string, cursorStore: CursorStore): Promise<ScanResult | null>;