@openclaw-china/shared 0.1.26 → 0.1.28

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw-china/shared",
-  "version": "0.1.26",
+  "version": "0.1.28",
   "type": "module",
   "exports": {
     ".": "./src/index.ts"

package/src/cron/index.ts

@@ -0,0 +1,115 @@
+const CRON_HIDDEN_PROMPT = `
+When creating or updating a cron task, use the main session's last route as the delivery target.
+- Do not ask the user for userId/chatId
+- sessionTarget="isolated"
+- payload.kind="agentTurn"
+- payload.deliver=true
+- Do not set payload.channel/to (fall back to last route automatically)
+- Do not call the message tool to send`;
+
+const CRON_TRIGGER_KEYWORDS = [
+  "定时",
+  "提醒",
+  "每分钟",
+  "每小时",
+  "每天",
+  "每周",
+  "几点",
+  "早上",
+  "晚上",
+  "工作日",
+  "cron",
+  "remind",
+  "reminder",
+  "schedule",
+  "scheduled",
+  "every minute",
+  "every hour",
+  "every day",
+  "daily",
+  "every week",
+  "weekly",
+  "weekday",
+  "workday",
+  "morning",
+  "evening",
+];
+
+const CRON_TRIGGER_PATTERNS = [
+  /提醒我/u,
+  /帮我定时/u,
+  /每.+提醒/u,
+  /每天.+发/u,
+  /remind me/iu,
+  /set (a )?reminder/iu,
+  /every .+ remind/iu,
+  /every day .+ (send|post|notify)/iu,
+  /schedule .+ (reminder|message|notification)/iu,
+];
+
+const CRON_EXCLUDE_PATTERNS = [
+  /是什么意思/u,
+  /区别/u,
+  /为什么/u,
+  /\bhelp\b/iu,
+  /文档/u,
+  /怎么用/u,
+  /what does|what's|meaning of/iu,
+  /difference/iu,
+  /why/iu,
+  /\bdocs?\b/iu,
+  /documentation/iu,
+  /how to/iu,
+  /usage/iu,
+];
+
+export function shouldInjectCronHiddenPrompt(text: string): boolean {
+  const normalized = text.trim();
+  if (!normalized) return false;
+  const lowered = normalized.toLowerCase();
+
+  for (const pattern of CRON_EXCLUDE_PATTERNS) {
+    if (pattern.test(lowered)) return false;
+  }
+
+  for (const keyword of CRON_TRIGGER_KEYWORDS) {
+    if (lowered.includes(keyword.toLowerCase())) return true;
+  }
+
+  return CRON_TRIGGER_PATTERNS.some((pattern) => pattern.test(normalized));
+}
+
+export function splitCronHiddenPrompt(text: string): { base: string; prompt?: string } {
+  const idx = text.indexOf(CRON_HIDDEN_PROMPT);
+  if (idx === -1) {
+    return { base: text };
+  }
+  const base = text.slice(0, idx).trimEnd();
+  return { base, prompt: CRON_HIDDEN_PROMPT };
+}
+
+export function appendCronHiddenPrompt(text: string): string {
+  if (!shouldInjectCronHiddenPrompt(text)) return text;
+  if (text.includes(CRON_HIDDEN_PROMPT)) return text;
+  return `${text}\n\n${CRON_HIDDEN_PROMPT}`;
+}
+
+export function applyCronHiddenPromptToContext<
+  T extends { Body?: string; RawBody?: string; CommandBody?: string }
+>(ctx: T): boolean {
+  const base =
+    (typeof ctx.RawBody === "string" && ctx.RawBody) ||
+    (typeof ctx.Body === "string" && ctx.Body) ||
+    (typeof ctx.CommandBody === "string" && ctx.CommandBody) ||
+    "";
+
+  if (!base) return false;
+
+  const next = appendCronHiddenPrompt(base);
+  if (next === base) return false;
+
+  ctx.CommandBody = next;
+  return true;
+}
+
+export { CRON_HIDDEN_PROMPT };

package/src/index.ts

@@ -1,9 +1,10 @@
-// @openclaw-china/shared
-// 共享工具模块
-
-export * from "./logger/index.js";
-export * from "./policy/index.js";
-export * from "./http/index.js";
-export * from "./types/common.js";
-export * from "./file/index.js";
-export * from "./media/index.js";
+// @openclaw-china/shared
+// 共享工具模块
+
+export * from "./logger/index.js";
+export * from "./policy/index.js";
+export * from "./http/index.js";
+export * from "./types/common.js";
+export * from "./file/index.js";
+export * from "./media/index.js";
+export * from "./cron/index.js";

package/src/media/index.ts

@@ -1,57 +1,65 @@
-/**
- * 媒体处理模块
- *
- * 提供统一的媒体解析、路径处理和文件读取功能
- *
- * @module @openclaw-china/shared/media
- */
-
-// 媒体解析
-export {
-  // 类型
-  type MediaType,
-  type ExtractedMedia,
-  type MediaParseResult,
-  type MediaParseOptions,
-  // 常量
-  IMAGE_EXTENSIONS,
-  AUDIO_EXTENSIONS,
-  VIDEO_EXTENSIONS,
-  NON_IMAGE_EXTENSIONS,
-  // 路径处理函数
-  isHttpUrl,
-  isFileUrl,
-  isLocalReference,
-  normalizeLocalPath,
-  stripTitleFromUrl,
-  getExtension,
-  isImagePath,
-  isNonImageFilePath,
-  detectMediaType,
-  // 媒体提取函数
-  extractMediaFromText,
-  extractImagesFromText,
-  extractFilesFromText,
-} from "./media-parser.js";
-
-// 媒体 IO
+/**
+ * 媒体处理模块
+ *
+ * 提供统一的媒体解析、路径处理和文件读取功能
+ *
+ * @module @openclaw-china/shared/media
+ */
+
+// 媒体解析
+export {
+  // 类型
+  type MediaType,
+  type ExtractedMedia,
+  type MediaParseResult,
+  type MediaParseOptions,
+  // 常量
+  IMAGE_EXTENSIONS,
+  AUDIO_EXTENSIONS,
+  VIDEO_EXTENSIONS,
+  NON_IMAGE_EXTENSIONS,
+  // 路径处理函数
+  isHttpUrl,
+  isFileUrl,
+  isLocalReference,
+  normalizeLocalPath,
+  stripTitleFromUrl,
+  getExtension,
+  isImagePath,
+  isNonImageFilePath,
+  detectMediaType,
+  // 媒体提取函数
+  extractMediaFromText,
+  extractImagesFromText,
+  extractFilesFromText,
+} from "./media-parser.js";
+
+// 媒体 IO
 export {
   // 类型
   type MediaReadResult,
   type MediaReadOptions,
+  type DownloadToTempFileResult,
+  type DownloadToTempFileOptions,
+  type FinalizeInboundMediaOptions,
+  type PruneInboundMediaDirOptions,
   type PathSecurityOptions,
   // 错误类
   FileSizeLimitError,
   MediaTimeoutError,
   PathSecurityError,
-  // 路径安全
-  validatePathSecurity,
-  getDefaultAllowedPrefixes,
-  // MIME 类型
-  getMimeType,
-  // 媒体读取函数
+  // 路径安全
+  validatePathSecurity,
+  getDefaultAllowedPrefixes,
+  // MIME 类型
+  getMimeType,
+  // 媒体读取函数
   fetchMediaFromUrl,
   readMediaFromLocal,
   readMedia,
   readMediaBatch,
+  downloadToTempFile,
+  finalizeInboundMediaFile,
+  pruneInboundMediaDir,
+  cleanupFileSafe,
 } from "./media-io.js";

package/src/media/media-io.test.ts

@@ -0,0 +1,180 @@
+import { afterEach, describe, expect, it } from "vitest";
+import * as fs from "node:fs";
+import * as fsPromises from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+import {
+  FileSizeLimitError,
+  MediaTimeoutError,
+  cleanupFileSafe,
+  downloadToTempFile,
+  finalizeInboundMediaFile,
+  pruneInboundMediaDir,
+} from "./media-io.js";
+
+const tempDirs: string[] = [];
+
+async function createTempDir(prefix: string): Promise<string> {
+  const dir = await fsPromises.mkdtemp(path.join(os.tmpdir(), prefix));
+  tempDirs.push(dir);
+  return dir;
+}
+
+afterEach(async () => {
+  for (const dir of tempDirs.splice(0, tempDirs.length)) {
+    await fsPromises.rm(dir, { recursive: true, force: true });
+  }
+});
+
+describe("downloadToTempFile", () => {
+  it("downloads HTTP response and stores a temp file", async () => {
+    const dir = await createTempDir("shared-media-io-");
+    const body = Buffer.from("hello-media", "utf8");
+    const fetchFn: typeof globalThis.fetch = async () =>
+      new Response(body, {
+        status: 200,
+        headers: {
+          "content-type": "image/png",
+          "content-length": String(body.length),
+        },
+      });
+
+    const result = await downloadToTempFile("https://example.com/a.png", {
+      fetch: fetchFn,
+      tempDir: dir,
+      tempPrefix: "dingtalk-file",
+    });
+
+    expect(result.path.startsWith(dir)).toBe(true);
+    expect(result.fileName.endsWith(".png")).toBe(true);
+    expect(result.size).toBe(body.length);
+    expect(result.contentType).toBe("image/png");
+
+    const saved = await fsPromises.readFile(result.path);
+    expect(saved.equals(body)).toBe(true);
+  });
+
+  it("throws FileSizeLimitError when Content-Length exceeds maxSize", async () => {
+    const fetchFn: typeof globalThis.fetch = async () =>
+      new Response("too-large", {
+        status: 200,
+        headers: {
+          "content-type": "application/octet-stream",
+          "content-length": "1024",
+        },
+      });
+
+    await expect(
+      downloadToTempFile("https://example.com/too-large.bin", {
+        fetch: fetchFn,
+        maxSize: 100,
+      })
+    ).rejects.toBeInstanceOf(FileSizeLimitError);
+  });
+
+  it("throws MediaTimeoutError on timeout", async () => {
+    const fetchFn: typeof globalThis.fetch = async (_url, init) =>
+      await new Promise<Response>((_resolve, reject) => {
+        const signal = init?.signal;
+        signal?.addEventListener("abort", () => {
+          const err = new Error("aborted");
+          (err as Error & { name: string }).name = "AbortError";
+          reject(err);
+        });
+      });
+
+    await expect(
+      downloadToTempFile("https://example.com/slow.bin", {
+        fetch: fetchFn,
+        timeout: 10,
+      })
+    ).rejects.toBeInstanceOf(MediaTimeoutError);
+  });
+});
+
+describe("cleanupFileSafe", () => {
+  it("removes file and ignores missing file", async () => {
+    const dir = await createTempDir("shared-media-clean-");
+    const filePath = path.join(dir, "a.txt");
+    await fsPromises.writeFile(filePath, "x", "utf8");
+    expect(fs.existsSync(filePath)).toBe(true);
+
+    await cleanupFileSafe(filePath);
+    expect(fs.existsSync(filePath)).toBe(false);
+
+    await expect(cleanupFileSafe(filePath)).resolves.toBeUndefined();
+    await expect(cleanupFileSafe(undefined)).resolves.toBeUndefined();
+  });
+});
+
+describe("inbound media retention", () => {
+  it("finalizes temp media into inbound/YYYY-MM-DD", async () => {
+    const tempDir = await createTempDir("shared-media-temp-");
+    const inboundDir = await createTempDir("shared-media-inbound-");
+    const sourcePath = path.join(tempDir, "img-1.jpg");
+    await fsPromises.writeFile(sourcePath, "abc", "utf8");
+
+    const finalPath = await finalizeInboundMediaFile({
+      filePath: sourcePath,
+      tempDir,
+      inboundDir,
+    });
+
+    expect(finalPath.startsWith(inboundDir)).toBe(true);
+    expect(fs.existsSync(finalPath)).toBe(true);
+    expect(fs.existsSync(sourcePath)).toBe(false);
+  });
+
+  it("does not move files outside tempDir", async () => {
+    const tempDir = await createTempDir("shared-media-temp-");
+    const inboundDir = await createTempDir("shared-media-inbound-");
+    const outsideDir = await createTempDir("shared-media-outside-");
+    const sourcePath = path.join(outsideDir, "a.txt");
+    await fsPromises.writeFile(sourcePath, "x", "utf8");
+
+    const finalPath = await finalizeInboundMediaFile({
+      filePath: sourcePath,
+      tempDir,
+      inboundDir,
+    });
+
+    expect(finalPath).toBe(sourcePath);
+    expect(fs.existsSync(sourcePath)).toBe(true);
+  });
+
+  it("prunes only expired files in date dirs and keeps recent files", async () => {
+    const inboundDir = await createTempDir("shared-media-prune-");
+    const oldDir = path.join(inboundDir, "2024-01-01");
+    const newDir = path.join(inboundDir, "2024-01-02");
+    await fsPromises.mkdir(oldDir, { recursive: true });
+    await fsPromises.mkdir(newDir, { recursive: true });
+
+    const oldFile = path.join(oldDir, "old.jpg");
+    const newFile = path.join(newDir, "new.jpg");
+    const nestedDir = path.join(oldDir, "nested");
+    const nestedFile = path.join(nestedDir, "nested.jpg");
+    await fsPromises.writeFile(oldFile, "old", "utf8");
+    await fsPromises.writeFile(newFile, "new", "utf8");
+    await fsPromises.mkdir(nestedDir, { recursive: true });
+    await fsPromises.writeFile(nestedFile, "nested", "utf8");
+
+    const oldTs = new Date("2024-01-01T00:00:00.000Z");
+    const newTs = new Date("2024-01-02T00:00:00.000Z");
+    await fsPromises.utimes(oldDir, oldTs, oldTs);
+    await fsPromises.utimes(oldFile, oldTs, oldTs);
+    await fsPromises.utimes(newDir, newTs, newTs);
+    await fsPromises.utimes(newFile, newTs, newTs);
+
+    const nowMs = new Date("2024-01-03T00:00:00.000Z").getTime();
+    await pruneInboundMediaDir({
+      inboundDir,
+      keepDays: 1,
+      nowMs,
+    });
+
+    expect(fs.existsSync(oldFile)).toBe(false);
+    expect(fs.existsSync(newFile)).toBe(true);
+    expect(fs.existsSync(nestedFile)).toBe(true);
+    expect(fs.existsSync(oldDir)).toBe(true);
+  });
+});