@core-workspace/infoflow-openclaw-plugin 2026.3.9 → 2026.3.27-beta.0

package/src/tools/cron/relay.ts

@@ -0,0 +1,1154 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import type { OpenClawConfig, OpenClawPluginService } from "openclaw/plugin-sdk/plugin-entry";
+import { normalizeInfoflowTarget } from "../../adapter/outbound/target-resolver.js";
+import { resolveDefaultInfoflowAccountId, resolveInfoflowAccount } from "../../channel/accounts.js";
+import { sendInfoflowMessage } from "../../channel/outbound.js";
+import type { InfoflowMessageContentItem } from "../../types.js";
+
+type CronRunStatus = "ok" | "error" | "skipped";
+
+type CronRunLogEntry = {
+  ts: number;
+  jobId: string;
+  action: "finished";
+  status?: CronRunStatus;
+  error?: string;
+  summary?: string;
+  sessionId?: string;
+  sessionKey?: string;
+  runAtMs?: number;
+  durationMs?: number;
+};
+
+type CronJobLike = {
+  id: string;
+  agentId?: string;
+  name?: string;
+  description?: string;
+  sessionKey?: string;
+  payload?: {
+    kind?: string;
+    deliver?: boolean;
+    channel?: string;
+    to?: string;
+  };
+  delivery?: {
+    mode?: string;
+    channel?: string;
+    to?: string;
+  };
+};
+
+type RelayStateFile = {
+  version: 1;
+  files: Record<string, number>;
+};
+
+type RelayTargetSource = "metadata" | "payload" | "delivery" | "session" | "none";
+
+type RelayStatus = "idle" | "pending" | "relayed" | "skipped";
+
+type RelayStatusJobEntry = {
+  jobId: string;
+  jobName: string;
+  channel: "infoflow";
+  target?: string;
+  targetSource: RelayTargetSource;
+  creatorSenderId?: string;
+  lastRun?: {
+    fileName: string;
+    line: number;
+    status?: CronRunStatus;
+    relayStatus: RelayStatus;
+    relayReason?: string;
+    time: string;
+    durationMs?: number;
+    summary?: string;
+    error?: string;
+  };
+};
+
+type RelayStatusRecentRun = {
+  jobId: string;
+  jobName: string;
+  target?: string;
+  targetSource: RelayTargetSource;
+  status?: CronRunStatus;
+  relayStatus: RelayStatus;
+  relayReason?: string;
+  time: string;
+  durationMs?: number;
+  summary?: string;
+  error?: string;
+  fileName: string;
+  line: number;
+};
+
+type RelayStatusFile = {
+  version: 1;
+  updatedAt: string;
+  runsDir: string;
+  jobsPath: string;
+  statePath: string;
+  jobs: RelayStatusJobEntry[];
+  recentRuns: RelayStatusRecentRun[];
+};
+
+export type InfoflowCronJobMetadata = {
+  version: 1;
+  mode: "direct";
+  target: string;
+  creatorSenderId?: string;
+  channel?: "infoflow";
+  source?: "infoflow_cron";
+  atAll?: boolean;
+  mentionUserIds?: string[];
+};
+
+const STATE_VERSION = 1;
+const RELAY_STATUS_VERSION = 1;
+const MIN_POLL_INTERVAL_MS = 500;
+const DEFAULT_POLL_INTERVAL_MS = 2000;
+const MAX_RECENT_RUNS = 50;
+const INFOFLOW_CHANNEL_ALIASES = new Set(["infoflow", "ruliu", "bdim"]);
+const INFOFLOW_CRON_METADATA_PREFIX = "infoflow-cron-meta:";
+const INFOFLOW_CRON_VISIBLE_MARKER = "[infoflow_cron]";
+
+function toObject(value: unknown): Record<string, unknown> | null {
+  if (!value || typeof value !== "object") {
+    return null;
+  }
+  return value as Record<string, unknown>;
+}
+
+function toNonNegativeInt(value: unknown): number | null {
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
+    return null;
+  }
+  return value;
+}
+
+function toStringOrUndefined(value: unknown): string | undefined {
+  return typeof value === "string" ? value : undefined;
+}
+
+function safeJsonParse(raw: string): unknown {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+function encodeBase64Url(raw: string): string {
+  return Buffer.from(raw, "utf8").toString("base64url");
+}
+
+function decodeBase64Url(raw: string): string | null {
+  try {
+    return Buffer.from(raw, "base64url").toString("utf8");
+  } catch {
+    return null;
+  }
+}
+
+function splitJsonlLines(raw: string): string[] {
+  if (!raw) {
+    return [];
+  }
+  const lines = raw.split(/\r?\n/);
+  if (!raw.endsWith("\n") && !raw.endsWith("\r\n")) {
+    lines.pop();
+  }
+  return lines.map((line) => line.trim()).filter(Boolean);
+}
+
+function truncateText(value: string | undefined, limit = 240): string | undefined {
+  const trimmed = value?.trim();
+  if (!trimmed) {
+    return undefined;
+  }
+  if (trimmed.length <= limit) {
+    return trimmed;
+  }
+  return `${trimmed.slice(0, Math.max(0, limit - 1)).trimEnd()}…`;
+}
+
+function buildVisibleDescriptionLines(metadata: InfoflowCronJobMetadata): string[] {
+  const lines = [
+    INFOFLOW_CRON_VISIBLE_MARKER,
+    "channel=infoflow",
+    "source=infoflow_cron",
+    `target=${metadata.target}`,
+  ];
+  const creatorSenderId = metadata.creatorSenderId?.trim();
+  if (creatorSenderId) {
+    lines.push(`creatorSenderId=${creatorSenderId}`);
+  }
+  if (metadata.atAll) {
+    lines.push("atAll=true");
+  } else if (metadata.mentionUserIds?.length) {
+    lines.push(`mentionUserIds=${metadata.mentionUserIds.join(",")}`);
+  }
+  return lines;
+}
+
+export function encodeInfoflowCronJobDescription(params: {
+  metadata: InfoflowCronJobMetadata;
+  userDescription?: string;
+}): string {
+  const metaLine = `${INFOFLOW_CRON_METADATA_PREFIX}${encodeBase64Url(
+    JSON.stringify(params.metadata),
+  )}`;
+  const extra = params.userDescription?.trim();
+  const lines = [metaLine, ...buildVisibleDescriptionLines(params.metadata)];
+  if (extra) {
+    lines.push("", extra);
+  }
+  return lines.join("\n");
+}
+
+export function parseInfoflowCronJobMetadata(
+  description: string | undefined,
+): InfoflowCronJobMetadata | null {
+  const lines =
+    description
+      ?.split(/\r?\n/)
+      .map((line) => line.trim())
+      .filter(Boolean) ?? [];
+  const metaLine = lines.find((line) => line.startsWith(INFOFLOW_CRON_METADATA_PREFIX));
+  if (!metaLine) {
+    return null;
+  }
+  const encoded = metaLine.slice(INFOFLOW_CRON_METADATA_PREFIX.length).trim();
+  if (!encoded) {
+    return null;
+  }
+  const decoded = decodeBase64Url(encoded);
+  if (!decoded) {
+    return null;
+  }
+  const parsed = toObject(safeJsonParse(decoded));
+  const version = toNonNegativeInt(parsed?.version);
+  const mode = toStringOrUndefined(parsed?.mode);
+  const target = normalizeInfoflowTarget(toStringOrUndefined(parsed?.target) ?? "");
+  if (version !== 1 || mode !== "direct" || !target) {
+    return null;
+  }
+  return {
+    version: 1,
+    mode: "direct",
+    target,
+    creatorSenderId: toStringOrUndefined(parsed?.creatorSenderId)?.trim() || undefined,
+    atAll: parsed?.atAll === true ? true : undefined,
+    mentionUserIds: Array.isArray(parsed?.mentionUserIds)
+      ? parsed.mentionUserIds
+          .filter((value): value is string => typeof value === "string")
+          .map((value) => value.trim())
+          .filter(Boolean)
+      : undefined,
+  };
+}
+
+export function parseCronRunLine(line: string): CronRunLogEntry | null {
+  const parsed = toObject(safeJsonParse(line));
+  if (!parsed || parsed.action !== "finished") {
+    return null;
+  }
+  const ts = toNonNegativeInt(parsed.ts);
+  const jobId = toStringOrUndefined(parsed.jobId)?.trim();
+  if (ts === null || !jobId) {
+    return null;
+  }
+  const statusRaw = toStringOrUndefined(parsed.status);
+  const status =
+    statusRaw === "ok" || statusRaw === "error" || statusRaw === "skipped"
+      ? (statusRaw as CronRunStatus)
+      : undefined;
+  return {
+    ts,
+    jobId,
+    action: "finished",
+    status,
+    error: toStringOrUndefined(parsed.error),
+    summary: toStringOrUndefined(parsed.summary),
+    sessionId: toStringOrUndefined(parsed.sessionId),
+    sessionKey: toStringOrUndefined(parsed.sessionKey),
+    runAtMs: toNonNegativeInt(parsed.runAtMs) ?? undefined,
+    durationMs: toNonNegativeInt(parsed.durationMs) ?? undefined,
+  };
+}
+
+function isInfoflowChannel(value: string | undefined): boolean {
+  if (!value) {
+    return false;
+  }
+  return INFOFLOW_CHANNEL_ALIASES.has(value.trim().toLowerCase());
+}
+
+export function cronJobAlreadyDeliveredToInfoflow(job: CronJobLike | undefined): boolean {
+  if (!job) {
+    return false;
+  }
+  if (
+    job.payload?.kind === "agentTurn" &&
+    job.payload?.deliver === true &&
+    isInfoflowChannel(job.payload.channel)
+  ) {
+    return true;
+  }
+  if (job.delivery?.mode === "announce" && isInfoflowChannel(job.delivery.channel)) {
+    return true;
+  }
+  return false;
+}
+
+export function resolveCronRelayTargetInfo(
+  cfg: OpenClawConfig,
+  job: CronJobLike | undefined,
+  fallbackTarget?: string,
+): { target?: string; source: RelayTargetSource } {
+  const directTarget = parseInfoflowCronJobMetadata(job?.description)?.target;
+  if (directTarget) {
+    return { target: directTarget, source: "metadata" };
+  }
+  const payloadTo = normalizeInfoflowTarget(job?.payload?.to ?? "");
+  if (payloadTo) {
+    return { target: payloadTo, source: "payload" };
+  }
+  const deliveryTo = normalizeInfoflowTarget(job?.delivery?.to ?? "");
+  if (deliveryTo) {
+    return { target: deliveryTo, source: "delivery" };
+  }
+  const fallback = normalizeInfoflowTarget(fallbackTarget ?? "");
+  if (fallback) {
+    return { target: fallback, source: "session" };
+  }
+  return { source: "none" };
+}
+
+export function resolveCronRelayTarget(
+  cfg: OpenClawConfig,
+  job: CronJobLike | undefined,
+  fallbackTarget?: string,
+): string | undefined {
+  return resolveCronRelayTargetInfo(cfg, job, fallbackTarget).target;
+}
+
+function formatStatus(status: CronRunStatus | undefined): string {
+  if (status === "ok") {
+    return "成功";
+  }
+  if (status === "error") {
+    return "失败";
+  }
+  if (status === "skipped") {
+    return "跳过";
+  }
+  return "未知";
+}
+
+function formatTimestamp(ts: number): string {
+  return new Date(ts).toLocaleString("zh-CN", { hour12: false });
+}
+
+function formatRelayStatus(status: RelayStatus): string {
+  if (status === "relayed") {
+    return "已转发";
+  }
+  if (status === "pending") {
+    return "待处理";
+  }
+  if (status === "skipped") {
+    return "已跳过";
+  }
+  return "未执行";
+}
+
+export function buildCronRelayMessage(params: {
+  entry: CronRunLogEntry;
+  job?: CronJobLike;
+  prefix: string;
+}): string {
+  const { entry, job, prefix } = params;
+  const jobLabel = job?.name?.trim() || entry.jobId;
+  const body = entry.summary?.trim() || entry.error?.trim() || "定时任务已执行。";
+  const metadata = parseInfoflowCronJobMetadata(job?.description);
+  if (metadata?.mode === "direct" && entry.status === "ok" && body) {
+    return body;
+  }
+  return [
+    `${prefix} ${jobLabel}`,
+    `状态: ${formatStatus(entry.status)}`,
+    `时间: ${formatTimestamp(entry.ts)}`,
+    `任务ID: ${entry.jobId}`,
+    "",
+    body,
+  ].join("\n");
+}
+
+function buildCronRelayContents(params: {
+  entry: CronRunLogEntry;
+  job?: CronJobLike;
+  prefix: string;
+  target?: string;
+}): InfoflowMessageContentItem[] {
+  const text = buildCronRelayMessage({
+    entry: params.entry,
+    job: params.job,
+    prefix: params.prefix,
+  });
+  const contents: InfoflowMessageContentItem[] = [];
+  const metadata = parseInfoflowCronJobMetadata(params.job?.description);
+  const isGroupTarget = /^group:\d+$/i.test(params.target ?? metadata?.target ?? "");
+
+  if (isGroupTarget) {
+    if (metadata?.atAll) {
+      contents.push({ type: "at", content: "all" });
+    } else if (metadata?.mentionUserIds?.length) {
+      contents.push({ type: "at", content: metadata.mentionUserIds.join(",") });
+    }
+  }
+
+  contents.push({ type: "markdown", content: text });
+  return contents;
+}
+
+function resolveCronRootDir(stateDir: string): string {
+  const root = stateDir.trim();
+  if (root) {
+    return root;
+  }
+  return path.join(os.homedir(), ".openclaw");
+}
+
+function markdownCell(value: string | undefined): string {
+  const normalized = value?.trim();
+  if (!normalized) {
+    return "-";
+  }
+  return normalized.replaceAll("|", "\\|").replaceAll("\n", "<br/>");
+}
+
+export function normalizeRelativeDataDir(input: string | undefined): string | null {
+  const raw = input?.trim();
+  if (!raw || path.isAbsolute(raw)) {
+    return null;
+  }
+  const normalized = path.posix.normalize(raw.replace(/\\/g, "/")).replace(/^\.\//, "").trim();
+  if (!normalized || normalized === "." || normalized === ".." || normalized.startsWith("../")) {
+    return null;
+  }
+  return normalized;
+}
+
+export function resolveCronRelayPrivateDataRoot(params: {
+  cfg: OpenClawConfig;
+  stateDir: string;
+}): { rootDir: string; privateDataRoot: string; usedDefault: boolean } {
+  const rootDir = resolveCronRootDir(params.stateDir);
+  const account = resolveInfoflowAccount({ cfg: params.cfg });
+  const normalized = normalizeRelativeDataDir(account.config.privateDataDir);
+  if (!normalized) {
+    return {
+      rootDir,
+      privateDataRoot: path.join(rootDir, "plugins/infoflow-private"),
+      usedDefault: true,
+    };
+  }
+  return {
+    rootDir,
+    privateDataRoot: path.join(rootDir, normalized),
+    usedDefault: false,
+  };
+}
+
+async function readRunFileLineCount(filePath: string): Promise<number> {
+  try {
+    const raw = await fs.readFile(filePath, "utf8");
+    return splitJsonlLines(raw).length;
+  } catch {
+    return 0;
+  }
+}
+
+async function readState(filePath: string): Promise<Map<string, number> | null> {
+  try {
+    const raw = await fs.readFile(filePath, "utf8");
+    const parsed = toObject(safeJsonParse(raw));
+    if (!parsed || parsed.version !== STATE_VERSION) {
+      return null;
+    }
+    const files = toObject(parsed.files);
+    if (!files) {
+      return null;
+    }
+    const map = new Map<string, number>();
+    for (const [name, value] of Object.entries(files)) {
+      const cursor = toNonNegativeInt(value);
+      if (cursor !== null) {
+        map.set(name, cursor);
+      }
+    }
+    return map;
+  } catch {
+    return null;
+  }
+}
+
+async function writeState(filePath: string, cursorMap: Map<string, number>): Promise<void> {
+  const files: Record<string, number> = {};
+  for (const [name, cursor] of cursorMap) {
+    files[name] = cursor;
+  }
+  const payload: RelayStateFile = {
+    version: STATE_VERSION,
+    files,
+  };
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  await fs.writeFile(filePath, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
+}
+
+async function writeRelayStatusArtifacts(params: {
+  jsonPath: string;
+  markdownPath: string;
+  payload: RelayStatusFile;
+}): Promise<void> {
+  await fs.mkdir(path.dirname(params.jsonPath), { recursive: true });
+  await fs.writeFile(params.jsonPath, `${JSON.stringify(params.payload, null, 2)}\n`, "utf8");
+
+  const lines = [
+    "# Infoflow Cron Relay Status",
+    "",
+    `更新时间: ${params.payload.updatedAt}`,
+    `runsDir: ${params.payload.runsDir}`,
+    `jobsPath: ${params.payload.jobsPath}`,
+    `statePath: ${params.payload.statePath}`,
+    "",
+    "## 当前任务",
+    "",
+    "| 任务 | 目标 | 最近执行 | Relay | 说明 |",
+    "| --- | --- | --- | --- | --- |",
+  ];
+
+  if (params.payload.jobs.length === 0) {
+    lines.push("| - | - | - | - | 当前没有可观测的 Infoflow cron 任务 |");
+  } else {
+    for (const job of params.payload.jobs) {
+      const lastRun = job.lastRun;
+      const lastStatus = lastRun ? `${lastRun.time} / ${formatStatus(lastRun.status)}` : "未执行";
+      const relayStatus = lastRun
+        ? formatRelayStatus(lastRun.relayStatus)
+        : formatRelayStatus("idle");
+      const note = [
+        `source=${job.targetSource}`,
+        lastRun?.relayReason ? `reason=${lastRun.relayReason}` : "",
+        job.creatorSenderId ? `creator=${job.creatorSenderId}` : "",
+      ]
+        .filter(Boolean)
+        .join("; ");
+      lines.push(
+        `| ${markdownCell(job.jobName)} | ${markdownCell(job.target)} | ${markdownCell(lastStatus)} | ${markdownCell(relayStatus)} | ${markdownCell(note)} |`,
+      );
+    }
+  }
+
+  lines.push(
+    "",
+    "## 最近执行",
+    "",
+    "| 时间 | 任务 | 状态 | Relay | 目标 | 摘要 |",
+    "| --- | --- | --- | --- | --- | --- |",
+  );
+  if (params.payload.recentRuns.length === 0) {
+    lines.push("| - | - | - | - | - | 暂无运行记录 |");
+  } else {
+    for (const run of params.payload.recentRuns) {
+      const summary = truncateText(run.summary ?? run.error, 120) ?? "-";
+      const relay = [formatRelayStatus(run.relayStatus), run.relayReason]
+        .filter(Boolean)
+        .join(" / ");
+      lines.push(
+        `| ${markdownCell(run.time)} | ${markdownCell(run.jobName)} | ${markdownCell(formatStatus(run.status))} | ${markdownCell(relay)} | ${markdownCell(run.target)} | ${markdownCell(summary)} |`,
+      );
+    }
+  }
+
+  await fs.writeFile(params.markdownPath, `${lines.join("\n")}\n`, "utf8");
+}
+
+async function readJobsFile(filePath: string): Promise<Map<string, CronJobLike>> {
+  const result = new Map<string, CronJobLike>();
+  try {
+    const raw = await fs.readFile(filePath, "utf8");
+    const parsed = toObject(safeJsonParse(raw));
+    const jobs = Array.isArray(parsed?.jobs) ? parsed.jobs : [];
+    for (const jobRaw of jobs) {
+      const obj = toObject(jobRaw);
+      const id = toStringOrUndefined(obj?.id)?.trim();
+      if (!id || result.has(id)) {
+        continue;
+      }
+      result.set(id, {
+        id,
+        agentId: toStringOrUndefined(obj?.agentId),
+        name: toStringOrUndefined(obj?.name),
+        description: toStringOrUndefined(obj?.description),
+        sessionKey: toStringOrUndefined(obj?.sessionKey),
+        payload: toObject(obj?.payload) as CronJobLike["payload"],
+        delivery: toObject(obj?.delivery) as CronJobLike["delivery"],
+      });
+    }
+  } catch {
+    // Ignore missing or unreadable files.
+  }
+  return result;
+}
+
+async function readJobsById(
+  filePath: string,
+  options?: { includeBackup?: boolean },
+): Promise<Map<string, CronJobLike>> {
+  const result = await readJobsFile(filePath);
+  if (!options?.includeBackup) {
+    return result;
+  }
+
+  const backup = await readJobsFile(`${filePath}.bak`);
+  for (const [jobId, job] of backup) {
+    if (!result.has(jobId)) {
+      result.set(jobId, job);
+    }
+  }
+  return result;
+}
+
+async function readLatestRunForFile(filePath: string): Promise<{
+  fileName: string;
+  line: number;
+  lineCount: number;
+  entry: CronRunLogEntry;
+} | null> {
+  const raw = await fs.readFile(filePath, "utf8").catch(() => "");
+  const lines = splitJsonlLines(raw);
+  for (let i = lines.length - 1; i >= 0; i -= 1) {
+    const parsed = parseCronRunLine(lines[i] ?? "");
+    if (parsed) {
+      return {
+        fileName: path.basename(filePath),
+        line: i + 1,
+        lineCount: lines.length,
+        entry: parsed,
+      };
+    }
+  }
+  return null;
+}
+
+function resolveRelayStatusForRun(params: {
+  job?: CronJobLike;
+  target?: string;
+  includeAlreadyDelivered: boolean;
+  cursor: number;
+  line: number;
+}): { relayStatus: RelayStatus; relayReason?: string } {
+  if (!params.target) {
+    return {
+      relayStatus: "skipped",
+      relayReason: "missing explicit relay target",
+    };
+  }
+  if (!params.includeAlreadyDelivered && cronJobAlreadyDeliveredToInfoflow(params.job)) {
+    return {
+      relayStatus: "skipped",
+      relayReason: "already delivered by OpenClaw delivery",
+    };
+  }
+  if (params.cursor < params.line) {
+    return {
+      relayStatus: "pending",
+      relayReason: "waiting for relay cursor",
+    };
+  }
+  return { relayStatus: "relayed" };
+}
+
+async function buildRelayStatusSnapshot(params: {
+  cfg: OpenClawConfig;
+  stateDir: string;
+  runsDir: string;
+  jobsPath: string;
+  statePath: string;
+  cursorMap: Map<string, number>;
+  includeAlreadyDelivered: boolean;
+}): Promise<RelayStatusFile> {
+  const currentJobsById = await readJobsById(params.jobsPath);
+  const jobsById = await readJobsById(params.jobsPath, { includeBackup: true });
+  const sessionStoreCache = new Map<string, Record<string, unknown>>();
+  const latestRuns = new Map<
+    string,
+    {
+      fileName: string;
+      line: number;
+      lineCount: number;
+      entry: CronRunLogEntry;
+    }
+  >();
+  const fileNames = (await fs.readdir(params.runsDir).catch(() => []))
+    .filter((name) => name.endsWith(".jsonl"))
+    .sort();
+  for (const fileName of fileNames) {
+    const latest = await readLatestRunForFile(path.join(params.runsDir, fileName));
+    if (latest) {
+      latestRuns.set(latest.entry.jobId, latest);
+    }
+  }
+
+  const jobs: RelayStatusJobEntry[] = [];
+  for (const [jobId, job] of currentJobsById) {
+    const metadata = parseInfoflowCronJobMetadata(job.description);
+    const latest = latestRuns.get(jobId);
+    const sessionTarget = await resolveCronRelaySessionTarget({
+      cfg: params.cfg,
+      stateDir: params.stateDir,
+      agentId: job.agentId,
+      sessionKey: latest?.entry.sessionKey ?? job.sessionKey,
+      cache: sessionStoreCache,
+    });
+    const targetInfo = resolveCronRelayTargetInfo(params.cfg, job, sessionTarget);
+    if (!metadata && !targetInfo.target && !cronJobAlreadyDeliveredToInfoflow(job)) {
+      continue;
+    }
+    const relayState = latest
+      ? resolveRelayStatusForRun({
+          job,
+          target: targetInfo.target,
+          includeAlreadyDelivered: params.includeAlreadyDelivered,
+          cursor: params.cursorMap.get(latest.fileName) ?? 0,
+          line: latest.line,
+        })
+      : null;
+    jobs.push({
+      jobId,
+      jobName: job.name?.trim() || jobId,
+      channel: "infoflow",
+      target: targetInfo.target,
+      targetSource: targetInfo.source,
+      creatorSenderId: metadata?.creatorSenderId,
+      lastRun: latest
+        ? {
+            fileName: latest.fileName,
+            line: latest.line,
+            status: latest.entry.status,
+            relayStatus: relayState?.relayStatus ?? "idle",
+            relayReason: relayState?.relayReason,
+            time: formatTimestamp(latest.entry.ts),
+            durationMs: latest.entry.durationMs,
+            summary: truncateText(latest.entry.summary),
+            error: truncateText(latest.entry.error),
+          }
+        : undefined,
+    });
+  }
+
+  jobs.sort((a, b) => a.jobName.localeCompare(b.jobName, "zh-CN"));
+
+  const recentRuns: RelayStatusRecentRun[] = [];
+  for (const latest of latestRuns.values()) {
+    const job = jobsById.get(latest.entry.jobId);
+    const sessionTarget = await resolveCronRelaySessionTarget({
+      cfg: params.cfg,
+      stateDir: params.stateDir,
+      agentId: job?.agentId,
+      sessionKey: latest.entry.sessionKey ?? job?.sessionKey,
+      cache: sessionStoreCache,
+    });
+    const targetInfo = resolveCronRelayTargetInfo(params.cfg, job, sessionTarget);
+    if (!job && !targetInfo.target) {
+      continue;
+    }
+    const relayState = resolveRelayStatusForRun({
+      job,
+      target: targetInfo.target,
+      includeAlreadyDelivered: params.includeAlreadyDelivered,
+      cursor: params.cursorMap.get(latest.fileName) ?? 0,
+      line: latest.line,
+    });
+    recentRuns.push({
+      jobId: latest.entry.jobId,
+      jobName: job?.name?.trim() || latest.entry.jobId,
+      target: targetInfo.target,
+      targetSource: targetInfo.source,
+      status: latest.entry.status,
+      relayStatus: relayState.relayStatus,
+      relayReason: relayState.relayReason,
+      time: formatTimestamp(latest.entry.ts),
+      durationMs: latest.entry.durationMs,
+      summary: truncateText(latest.entry.summary),
+      error: truncateText(latest.entry.error),
+      fileName: latest.fileName,
+      line: latest.line,
+    });
+  }
+
+  recentRuns.sort((a, b) => {
+    const ta = latestRuns.get(a.jobId)?.entry.ts ?? 0;
+    const tb = latestRuns.get(b.jobId)?.entry.ts ?? 0;
+    return tb - ta;
+  });
+
+  return {
+    version: RELAY_STATUS_VERSION,
+    updatedAt: new Date().toISOString(),
+    runsDir: params.runsDir,
+    jobsPath: params.jobsPath,
+    statePath: params.statePath,
+    jobs,
+    recentRuns: recentRuns.slice(0, MAX_RECENT_RUNS),
+  };
+}
+
+function normalizeAgentId(value: string | undefined): string {
+  const raw = value?.trim().toLowerCase();
+  return raw || "main";
+}
+
+function expandHomePrefix(filePath: string): string {
+  if (filePath === "~") {
+    return os.homedir();
+  }
+  if (filePath.startsWith("~/")) {
+    return path.join(os.homedir(), filePath.slice(2));
+  }
+  return filePath;
+}
+
+function resolveCronRelaySessionStorePath(params: {
+  cfg: OpenClawConfig;
+  stateDir: string;
+  agentId?: string;
+}): string {
+  const agentId = normalizeAgentId(params.agentId);
+  const sessionConfig = toObject(params.cfg.session);
+  const configuredStore = toStringOrUndefined(sessionConfig?.store)?.trim();
+  if (!configuredStore) {
+    return path.join(params.stateDir, "agents", agentId, "sessions", "sessions.json");
+  }
+  const expanded = configuredStore.replaceAll("{agentId}", agentId);
+  return path.resolve(expandHomePrefix(expanded));
+}
+
+export function resolveInfoflowTargetFromSessionEntry(params: {
+  entry: unknown;
+  sessionKey?: string;
+}): string | undefined {
+  const sessionKeyTarget = resolveInfoflowTargetFromSessionKey(params.sessionKey);
+  const entry = toObject(params.entry);
+  if (!entry) {
+    return sessionKeyTarget;
+  }
+
+  const delivery = toObject(entry.deliveryContext);
+  const channel = toStringOrUndefined(delivery?.channel) ?? toStringOrUndefined(entry.lastChannel);
+  if (channel && !isInfoflowChannel(channel)) {
+    return undefined;
+  }
+  if (!channel && !params.sessionKey?.toLowerCase().includes(":infoflow:")) {
+    return undefined;
+  }
+
+  return (
+    normalizeInfoflowTarget(
+      toStringOrUndefined(delivery?.to) ?? toStringOrUndefined(entry.lastTo) ?? "",
+    ) ?? sessionKeyTarget
+  );
+}
+
+export function resolveInfoflowTargetFromSessionKey(
+  sessionKey: string | undefined,
+): string | undefined {
+  const trimmed = sessionKey?.trim();
+  if (!trimmed || !trimmed.toLowerCase().includes(":infoflow:")) {
+    return undefined;
+  }
+
+  const groupMatch = trimmed.match(/:group:(\d+)(?::member:[^:]+)?$/i);
+  if (groupMatch) {
+    return normalizeInfoflowTarget(`infoflow:group:${groupMatch[1]}`);
+  }
+
+  const directMatch = trimmed.match(/:direct:([^:]+)$/i);
+  if (directMatch) {
+    return normalizeInfoflowTarget(`infoflow:${directMatch[1]}`);
+  }
+
+  return undefined;
+}
+
+async function resolveCronRelaySessionTarget(params: {
+  cfg: OpenClawConfig;
+  stateDir: string;
+  agentId?: string;
+  sessionKey?: string;
+  cache: Map<string, Record<string, unknown>>;
+}): Promise<string | undefined> {
+  const sessionKey = params.sessionKey?.trim();
+  if (!sessionKey) {
+    return undefined;
+  }
+
+  const storePath = resolveCronRelaySessionStorePath({
+    cfg: params.cfg,
+    stateDir: params.stateDir,
+    agentId: params.agentId,
+  });
+  let store = params.cache.get(storePath);
+  if (!store) {
+    const raw = await fs.readFile(storePath, "utf8").catch(() => "");
+    const parsed = toObject(safeJsonParse(raw));
+    store = parsed ?? {};
+    params.cache.set(storePath, store);
+  }
+
+  return resolveInfoflowTargetFromSessionEntry({
+    entry: store[sessionKey],
+    sessionKey,
+  });
+}
+
+async function relayCronMessage(params: {
+  cfg: OpenClawConfig;
+  accountId: string;
+  to: string;
+  contents: InfoflowMessageContentItem[];
+}): Promise<void> {
+  const result = await sendInfoflowMessage({
+    cfg: params.cfg,
+    accountId: params.accountId,
+    to: params.to,
+    contents: params.contents,
+  });
+  if (!result.ok) {
+    throw new Error(result.error ?? "failed to relay cron message");
+  }
+}
+
+export function createInfoflowCronRelayService(): OpenClawPluginService {
+  let timer: NodeJS.Timeout | null = null;
+  let inFlight = false;
+  let stopped = false;
+  let statePath = "";
+  let statusJsonPath = "";
+  let statusMarkdownPath = "";
+  let runsDir = "";
+  let jobsPath = "";
+  const cursorMap = new Map<string, number>();
+
+  const persistRelayStatus = async (
+    ctx: Parameters<OpenClawPluginService["start"]>[0],
+    includeAlreadyDelivered: boolean,
+  ): Promise<void> => {
+    if (!statusJsonPath || !statusMarkdownPath) {
+      return;
+    }
+    const payload = await buildRelayStatusSnapshot({
+      cfg: ctx.config,
+      stateDir: ctx.stateDir,
+      runsDir,
+      jobsPath,
+      statePath,
+      cursorMap,
+      includeAlreadyDelivered,
+    });
+    await writeRelayStatusArtifacts({
+      jsonPath: statusJsonPath,
+      markdownPath: statusMarkdownPath,
+      payload,
+    });
+  };
+
+  const tick = async (ctx: Parameters<OpenClawPluginService["start"]>[0]): Promise<void> => {
+    if (stopped || inFlight) {
+      return;
+    }
+    inFlight = true;
+    try {
+      const cfg = ctx.config;
+      const accountId = resolveDefaultInfoflowAccountId(cfg);
+      const account = resolveInfoflowAccount({ cfg, accountId });
+      if (!account.enabled || !account.config.cronRelay.enabled) {
+        ctx.logger.warn(
+          `infoflow cron-relay: skipping tick, account.enabled=${account.enabled}, cronRelay.enabled=${account.config.cronRelay.enabled}`,
+        );
+        return;
+      }
+
+      const fileNames = (await fs.readdir(runsDir).catch(() => []))
+        .filter((name) => name.endsWith(".jsonl"))
+        .sort();
+      if (fileNames.length === 0) {
+        return;
+      }
+
+      const jobsById = await readJobsById(jobsPath, { includeBackup: true });
+      const sessionStoreCache = new Map<string, Record<string, unknown>>();
+      let dirty = false;
+      for (const fileName of fileNames) {
+        const filePath = path.join(runsDir, fileName);
+        const raw = await fs.readFile(filePath, "utf8").catch(() => "");
+        const lines = splitJsonlLines(raw);
+        const currentCursorRaw = cursorMap.get(fileName) ?? 0;
+        const currentCursor = Math.min(Math.max(0, currentCursorRaw), lines.length);
+
+        let nextCursor = currentCursor;
+        for (let i = currentCursor; i < lines.length; i += 1) {
+          try {
+            const parsed = parseCronRunLine(lines[i] ?? "");
+            if (!parsed) {
+              nextCursor = i + 1;
+              dirty = true;
+              continue;
+            }
+
+            const job = jobsById.get(parsed.jobId);
+            if (
+              !account.config.cronRelay.includeAlreadyDelivered &&
+              cronJobAlreadyDeliveredToInfoflow(job)
+            ) {
+              nextCursor = i + 1;
+              dirty = true;
+              continue;
+            }
+
+            const sessionTarget = await resolveCronRelaySessionTarget({
+              cfg,
+              stateDir: ctx.stateDir,
+              agentId: job?.agentId,
+              sessionKey: parsed.sessionKey ?? job?.sessionKey,
+              cache: sessionStoreCache,
+            });
+            const relayTo = resolveCronRelayTarget(cfg, job, sessionTarget);
+            if (!relayTo) {
+              ctx.logger.warn(
+                `infoflow cron-relay: skip job ${parsed.jobId}, missing explicit relay target (use infoflow_cron or create the cron from an infoflow session with sessionKey)`,
+              );
+              nextCursor = i + 1;
+              dirty = true;
+              continue;
+            }
+
+            const relayContents = buildCronRelayContents({
+              entry: parsed,
+              job,
+              prefix: account.config.cronRelay.prefix,
+              target: relayTo,
+            });
+
+            await relayCronMessage({
+              cfg,
+              accountId: account.accountId,
+              to: relayTo,
+              contents: relayContents,
+            });
+            ctx.logger.info(
+              `infoflow cron-relay relayed job=${parsed.jobId} status=${parsed.status ?? "unknown"} to=${relayTo}`,
+            );
+            nextCursor = i + 1;
+            dirty = true;
+          } catch (err) {
+            ctx.logger.warn(
+              `infoflow cron-relay: file=${fileName} line=${i + 1} relay failed: ${String(err)}`,
+            );
+            break;
+          }
+        }
+
+        if (nextCursor !== currentCursorRaw) {
+          cursorMap.set(fileName, nextCursor);
+          dirty = true;
+        }
+      }
+
+      if (dirty) {
+        await writeState(statePath, cursorMap);
+      }
+      await persistRelayStatus(ctx, account.config.cronRelay.includeAlreadyDelivered);
+    } catch (err) {
+      ctx.logger.warn(`infoflow cron-relay tick failed: ${String(err)}`);
+      const account = resolveInfoflowAccount({ cfg: ctx.config });
+      await persistRelayStatus(ctx, account.config.cronRelay.includeAlreadyDelivered).catch(
+        () => {},
+      );
+    } finally {
+      inFlight = false;
+    }
+  };
+
+  return {
+    id: "infoflow-cron-relay",
+    async start(ctx) {
+      stopped = false;
+      inFlight = false;
+      cursorMap.clear();
+      const { rootDir, privateDataRoot, usedDefault } = resolveCronRelayPrivateDataRoot({
+        cfg: ctx.config,
+        stateDir: ctx.stateDir,
+      });
+      runsDir = path.join(rootDir, "cron", "runs");
+      jobsPath = path.join(rootDir, "cron", "jobs.json");
+      statePath = path.join(privateDataRoot, "cron-relay-state.json");
+      statusJsonPath = path.join(privateDataRoot, "cron-relay-status.json");
+      statusMarkdownPath = path.join(privateDataRoot, "cron-relay-status.md");
+      if (usedDefault) {
+        ctx.logger.warn(
+          "infoflow cron-relay: invalid channels.infoflow.privateDataDir, fallback to default",
+        );
+      }
+
+      const loaded = await readState(statePath);
+      if (loaded) {
+        for (const [fileName, cursor] of loaded) {
+          cursorMap.set(fileName, cursor);
+        }
+      } else {
+        const fileNames = (await fs.readdir(runsDir).catch(() => []))
+          .filter((name) => name.endsWith(".jsonl"))
+          .sort();
+        for (const fileName of fileNames) {
+          const filePath = path.join(runsDir, fileName);
+          cursorMap.set(fileName, await readRunFileLineCount(filePath));
+        }
+        await writeState(statePath, cursorMap);
+      }
+
+      const account = resolveInfoflowAccount({ cfg: ctx.config });
+      await persistRelayStatus(ctx, account.config.cronRelay.includeAlreadyDelivered);
+      const pollIntervalMs = Math.max(
+        MIN_POLL_INTERVAL_MS,
+        account.config.cronRelay.pollIntervalMs || DEFAULT_POLL_INTERVAL_MS,
+      );
+      timer = setInterval(() => {
+        void tick(ctx);
+      }, pollIntervalMs);
+      await tick(ctx);
+      ctx.logger.info(
+        `infoflow cron-relay started (runsDir=${runsDir}, statePath=${statePath}, statusPath=${statusMarkdownPath}, pollIntervalMs=${pollIntervalMs})`,
+      );
+    },
+    async stop(ctx) {
+      stopped = true;
+      if (timer) {
+        clearInterval(timer);
+        timer = null;
+      }
+      await writeState(statePath, cursorMap).catch(() => {});
+      const account = resolveInfoflowAccount({ cfg: ctx.config });
+      await persistRelayStatus(ctx, account.config.cronRelay.includeAlreadyDelivered).catch(
+        () => {},
+      );
+      ctx.logger.info("infoflow cron-relay stopped");
+    },
+  };
+}