aitable-workflow-cli 0.1.15 → 0.1.16-beta.1786022310508

package/templates/support-qa/lib/echo-guard.ts

@@ -1,50 +0,0 @@
-import { createHash } from "node:crypto";
-
-/**
- * 出站回声防护（echo guard）
- *
- * 背景：webhook 发出的机器人回复可能被 dws 轮询以"某个真人"的名义重新拉回
- * （真实案例：机器人答案以创建者名义回流，身份匹配失效，被当新消息判定建行）。
- * 方案：reply 发送成功后发布内容指纹到 globalVar；conversation_handler 同步比对，
- * 命中即按机器人消息处理（只记历史，不建单）。
- */
-
-const VAR_KEY = "sent_reply_fingerprints";
-const CAPACITY = 50;
-const TTL_MS = 10 * 60 * 1000;
-
-type Fingerprint = { h: string; ts: number };
-
-function normalize(content: string): string {
-  return content.replace(/\s+/g, "").slice(0, 300);
-}
-
-export function replyFingerprint(content: string): string {
-  return createHash("sha1").update(normalize(content)).digest("hex");
-}
-
-function loadList(get: (key: string) => unknown): Fingerprint[] {
-  const raw = get(VAR_KEY);
-  if (!Array.isArray(raw)) return [];
-  const now = Date.now();
-  return (raw as Fingerprint[]).filter((f) => f && typeof f.h === "string" && now - f.ts <= TTL_MS);
-}
-
-/** reply 发送成功后调用：发布指纹（带容量与 TTL 裁剪） */
-export function publishSentFingerprint(
-  get: (key: string) => unknown,
-  set: (key: string, value: unknown) => void,
-  content: string,
-): void {
-  const list = loadList(get);
-  list.push({ h: replyFingerprint(content), ts: Date.now() });
-  while (list.length > CAPACITY) list.shift();
-  set(VAR_KEY, list);
-}
-
-/** 入站消息比对：近期是否是我们自己发出的内容（同步、无 IO） */
-export function isRecentOutboundEcho(get: (key: string) => unknown, content: string): boolean {
-  if (!content.trim()) return false;
-  const h = replyFingerprint(content);
-  return loadList(get).some((f) => f.h === h);
-}

package/templates/support-qa/lib/fastpath.ts

@@ -1,227 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-import path from "node:path";
-import { parse as parseYaml } from "yaml";
-import { z } from "zod";
-
-/**
- * fastpath 声明式规则引擎（support-qa L3，场景层，零 core 依赖）
- *
- * 确定性秒回：按 profile/fastpath/known-answers.yml 声明的规则，用纯匹配（非 LLM）
- * 把命中消息直接映射为固定话术。规则三选一：
- *   - template：与消息全文（空白归一后）全等；
- *   - contains：消息包含该子串（单向）；
- *   - regex：正则 test 消息。
- * 另有 safety 安全兜底关键词（最高优先级），命中即返回安全话术。
- *
- * 关键不变量——【单向匹配】：一律「消息文案 message 包含/匹配规则模式」，
- * 绝不反向（规则 key/pattern 包含 message）。这修复了 aitable-handoff
- * known-error-match 里 `errorMessage.includes(k) || k.includes(errorMessage)`
- * 的双向 includes 误配 bug（短消息会错误命中长规则）。
- *
- * 关键不变量——【只看用户本轮新话】：规则匹配前剥离钉钉「引用消息:」块
- * （引用内容往往就是本机器人上一轮的回复，不剥离就会在用户追问时把同一段
- * 话术复读一遍）；safety 安全兜底依然看全文，防止注入/敏感内容藏在引用块里绕过拦截。
- *
- * 关闭语义：profile.fastpath.rules 未配置或文件缺失 → config=null → 透传给 answer。
- */
-
-export const fastpathRulesSchema = z.object({
-  safety: z.object({
-    keywords: z.array(z.string().min(1)).min(1),
-    reply: z.string().min(1),
-  }).optional(),
-  rules: z.array(z.object({
-    key: z.string().min(1),
-    template: z.string().optional(),
-    contains: z.string().optional(),
-    regex: z.string().optional(),
-    reply: z.string().min(1),
-  }).refine(
-    (r) => [r.template, r.contains, r.regex].filter((v) => v !== undefined && v.trim()).length === 1,
-    { message: "必须且只能有 template/contains/regex 之一" },
-  )),
-});
-
-export type FastpathRule = {
-  /** 规则标识（报错/日志文案含此 key，便于排障与追溯） */
-  key: string;
-  template?: string;
-  contains?: string;
-  regex?: string;
-  /** 加载时预编译的正则（与校验同一实例），避免逐消息重编 */
-  compiledRegex?: RegExp;
-  reply: string;
-};
-
-export type FastpathSafety = {
-  keywords: string[];
-  reply: string;
-};
-
-export type FastpathConfig = {
-  safety?: FastpathSafety;
-  rules: FastpathRule[];
-};
-
-export type FastpathMatch = {
-  key: string;
-  reply: string;
-  kind: "safety" | "template" | "contains" | "regex";
-};
-
-export type FastpathLoadResult = {
-  /** null = 未配置或文件缺失（fastpath 关闭，透传 answer） */
-  config: FastpathConfig | null;
-  issues: string[];
-};
-
-const cache = new Map<string, FastpathLoadResult>();
-
-/** 空白归一（template 全等匹配用） */
-function normalizeWs(s: string): string {
-  return s.replace(/\s+/g, " ").trim();
-}
-
-/**
- * 钉钉「引用消息:」标记：其后内容是被引用的历史消息，不属于用户本轮诉求。
- * 包含半角/全角冒号两种变体（不同客户端文案不一致）。
- */
-const QUOTE_MARKERS = ["引用消息:", "引用消息："];
-
-/**
- * 剥离引用块，只保留用户本轮新话（确定性秒回只能据用户新诉求判定）。
- *
- * 为何需要：用户带引用追问时，引用块里往往完整包含上一轮的报错文案与本机器人的
- * 回复，全文 contains 会再匹配到同一条规则 → 复读同一段话术（7-25 评测 g4-21/g4-22）。
- *
- * 边界：剥离后为空（用户只转发引用、自己没打字）→ 返回原文，那种场景本来就应该秒回。
- */
-export function stripQuotedBlock(message: string): string {
-  const msg = message ?? "";
-  let cut = msg.length;
-  for (const marker of QUOTE_MARKERS) {
-    const i = msg.indexOf(marker);
-    if (i >= 0 && i < cut) cut = i;
-  }
-  if (cut >= msg.length) return msg;
-  const head = msg.slice(0, cut).trim();
-  return head || msg;
-}
-
-/** 加载并校验 fastpath 规则；按解析后的绝对路径缓存 */
-export function loadFastpathRules(configDir: string, rulesRel: string | undefined): FastpathLoadResult {
-  const rel = String(rulesRel ?? "").trim();
-  if (!rel) return { config: null, issues: [] }; // 未配置 → 关闭
-  const abs = path.resolve(configDir, "profile", rel);
-  const hit = cache.get(abs);
-  if (hit) return hit;
-
-  let res: FastpathLoadResult;
-  if (!existsSync(abs)) {
-    // 文件缺失 → 关闭（graceful，不阻断 L0）；preflight 另行告警
-    res = { config: null, issues: [`fastpath.rules 引用的文件不存在: profile/${rel}`] };
-  } else {
-    try {
-      const raw = (parseYaml(readFileSync(abs, "utf8")) ?? {}) as Record<string, unknown>;
-      const issues: string[] = [];
-      res = { config: normalizeConfig(raw, issues), issues };
-    } catch (err) {
-      res = { config: null, issues: [`fastpath 规则解析失败 profile/${rel}: ${err instanceof Error ? err.message : String(err)}`] };
-    }
-  }
-  cache.set(abs, res);
-  return res;
-}
-
-function normalizeConfig(raw: Record<string, unknown>, issues: string[]): FastpathConfig {
-  const rules: FastpathRule[] = [];
-  const rawRules = Array.isArray(raw.rules) ? raw.rules : [];
-  for (let i = 0; i < rawRules.length; i++) {
-    const r = rawRules[i] as Record<string, unknown> | null;
-    if (!r || typeof r !== "object") {
-      issues.push(`rules[${i}] 不是对象`);
-      continue;
-    }
-    const key = String(r.key ?? "").trim();
-    const reply = String(r.reply ?? "").trim();
-    if (!key) {
-      issues.push(`rules[${i}] 缺少 key`);
-      continue;
-    }
-    if (!reply) {
-      issues.push(`rules[${key}] 缺少 reply`);
-      continue;
-    }
-    const present = (["template", "contains", "regex"] as const).filter(
-      (k) => typeof r[k] === "string" && String(r[k]).trim(),
-    );
-    if (present.length !== 1) {
-      issues.push(`rules[${key}] 必须且只能有 template/contains/regex 之一（当前 ${present.length} 个）`);
-      continue;
-    }
-    const rule: FastpathRule = { key, reply };
-    if (typeof r.template === "string") rule.template = r.template;
-    if (typeof r.contains === "string") rule.contains = r.contains;
-    if (typeof r.regex === "string") {
-      try {
-        rule.compiledRegex = new RegExp(r.regex);
-      } catch {
-        issues.push(`rules[${key}] 非法正则: ${r.regex}`);
-        continue;
-      }
-      rule.regex = r.regex;
-    }
-    rules.push(rule);
-  }
-
-  let safety: FastpathSafety | undefined;
-  const rawSafety = raw.safety as Record<string, unknown> | undefined;
-  if (rawSafety && typeof rawSafety === "object") {
-    const keywords = Array.isArray(rawSafety.keywords)
-      ? rawSafety.keywords.map((k) => String(k)).filter(Boolean)
-      : [];
-    const reply = String(rawSafety.reply ?? "").trim();
-    if (keywords.length > 0 && reply) safety = { keywords, reply };
-    else issues.push("safety 需同时提供非空 keywords 与 reply（否则忽略）");
-  }
-
-  return { safety, rules };
-}
-
-/**
- * 匹配 fastpath（单向）：安全兜底优先，其次规则按声明顺序。
- * 一律「消息包含/匹配规则模式」，不做反向包含。
- *
- * safety 看全文（敏感内容/注入藏在引用块里也要拦）；普通规则只看剥离引用后的
- * 用户新话（避免带引用追问时复读上一轮话术）。
- */
-export function matchFastpath(config: FastpathConfig | null, message: string): FastpathMatch | null {
-  if (!config) return null;
-  const msg = message ?? "";
-  if (!msg.trim()) return null;
-
-  // 安全兜底：消息（含引用内容）包含任一安全关键词（单向）
-  if (config.safety) {
-    for (const kw of config.safety.keywords) {
-      if (kw && msg.includes(kw)) return { key: "safety", reply: config.safety.reply, kind: "safety" };
-    }
-  }
-
-  // 普通规则：只对用户本轮新话匹配
-  const own = stripQuotedBlock(msg);
-  if (!own.trim()) return null;
-
-  for (const rule of config.rules) {
-    if (rule.template !== undefined) {
-      if (normalizeWs(own) === normalizeWs(rule.template)) {
-        return { key: rule.key, reply: rule.reply, kind: "template" };
-      }
-    } else if (rule.contains !== undefined) {
-      if (own.includes(rule.contains)) return { key: rule.key, reply: rule.reply, kind: "contains" }; // 单向
-    } else if (rule.regex !== undefined) {
-      // 用预编译实例（加载期已校验），避免逐消息重编
-      if (rule.compiledRegex?.test(own)) return { key: rule.key, reply: rule.reply, kind: "regex" };
-    }
-  }
-  return null;
-}

package/templates/support-qa/lib/owner-mention.ts

@@ -1,140 +0,0 @@
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-
-export type OwnerGroupMention =
-  | { mode: "at"; userId: string }
-  | { mode: "name" };
-
-export type OwnerMentionCommandRunner = (
-  args: string[],
-  timeoutMs: number,
-) => Promise<unknown>;
-
-export type OwnerMentionDeps = {
-  runDws?: OwnerMentionCommandRunner;
-  now?: () => number;
-};
-
-type CacheEntry<T> = { value: T; expiresAt: number };
-
-const execFileAsync = promisify(execFile);
-const DWS_TIMEOUT_MS = 8_000;
-const MEMBER_CACHE_TTL_MS = 10 * 60_000;
-const MEMBER_CACHE_MAX = 500;
-
-const memberCache = new Map<string, CacheEntry<OwnerGroupMention>>();
-let commandRunnerOverride: OwnerMentionCommandRunner | undefined;
-
-function getCached<T>(
-  cache: Map<string, CacheEntry<T>>,
-  key: string,
-  now: number,
-): T | undefined {
-  const hit = cache.get(key);
-  if (!hit) return undefined;
-  if (hit.expiresAt <= now) {
-    cache.delete(key);
-    return undefined;
-  }
-  // Map 插入顺序作为轻量 LRU；命中后移到队尾。
-  cache.delete(key);
-  cache.set(key, hit);
-  return hit.value;
-}
-
-function setCached<T>(
-  cache: Map<string, CacheEntry<T>>,
-  key: string,
-  value: T,
-  expiresAt: number,
-  max: number,
-): void {
-  cache.delete(key);
-  cache.set(key, { value, expiresAt });
-  while (cache.size > max) {
-    const oldest = cache.keys().next().value as string | undefined;
-    if (oldest === undefined) break;
-    cache.delete(oldest);
-  }
-}
-
-async function defaultRunDws(args: string[], timeoutMs: number): Promise<unknown> {
-  const { stdout } = await execFileAsync("dws", args, {
-    encoding: "utf8",
-    timeout: timeoutMs,
-    maxBuffer: 5 * 1024 * 1024,
-  });
-  return JSON.parse(String(stdout));
-}
-
-function memberList(payload: unknown): Array<Record<string, unknown>> {
-  if (!payload || typeof payload !== "object") return [];
-  const obj = payload as Record<string, unknown>;
-  const result = obj.result;
-  if (!result || typeof result !== "object" || Array.isArray(result)) return [];
-  const members = (result as Record<string, unknown>).members;
-  return Array.isArray(members)
-    ? members.filter((item): item is Record<string, unknown> => Boolean(item) && typeof item === "object" && !Array.isArray(item))
-    : [];
-}
-
-function readOpenDingTalkId(item: Record<string, unknown>): string {
-  const value = item.openDingTalkId ?? item.openDingtalkId;
-  return typeof value === "string" ? value.trim() : "";
-}
-
-/**
- * 判定 Owner 是否能在目标群真实 @。
- *
- * Owner 的 userId/openDingTalkId 由 config-sync 从功能模块人员配置表解析
- * （dws contact user get→search 链路）后随快照传入，这里只做群成员在群校验。
- * 任一参数、命令、超时或响应解析失败都返回 name；本函数不向主流程抛错。
- */
-export async function resolveOwnerGroupMention(
-  conversationId: string,
-  owner: { userId: string; openDingTalkId?: string },
-  deps: OwnerMentionDeps = {},
-): Promise<OwnerGroupMention> {
-  const cid = String(conversationId ?? "").trim();
-  const userId = String(owner?.userId ?? "").trim();
-  const openDingTalkId = String(owner?.openDingTalkId ?? "").trim();
-  if (!cid || !userId || !openDingTalkId) return { mode: "name" };
-
-  const now = (deps.now ?? Date.now)();
-  const cacheKey = `${cid}\u0000${userId}\u0000${openDingTalkId}`;
-  const cached = getCached(memberCache, cacheKey, now);
-  if (cached !== undefined) return cached;
-
-  const fallback: OwnerGroupMention = { mode: "name" };
-  const runDws = deps.runDws ?? commandRunnerOverride ?? defaultRunDws;
-
-  let result: OwnerGroupMention = fallback;
-  try {
-    const payload = await runDws([
-      "chat", "group", "members", "list-by-ids",
-      "--id", cid,
-      "--users", openDingTalkId,
-      "--format", "json",
-      "--timeout", "8",
-    ], DWS_TIMEOUT_MS);
-    const matched = memberList(payload).some((member) => readOpenDingTalkId(member) === openDingTalkId);
-    if (matched) result = { mode: "at", userId };
-  } catch {
-    result = fallback;
-  }
-
-  setCached(memberCache, cacheKey, result, now + MEMBER_CACHE_TTL_MS, MEMBER_CACHE_MAX);
-  return result;
-}
-
-/** 仅供单测隔离模块级缓存。 */
-export function resetOwnerMentionCachesForTests(): void {
-  memberCache.clear();
-}
-
-/** 仅供 recipe 单测注入 dws runner；传 undefined 恢复真实命令。 */
-export function setOwnerMentionCommandRunnerForTests(
-  runner?: OwnerMentionCommandRunner,
-): void {
-  commandRunnerOverride = runner;
-}

package/templates/support-qa/lib/profile-guard.ts

@@ -1,55 +0,0 @@
-import type { RecipeContext, RecipeResult } from "aitable-workflow-core";
-import { ensureAssembled } from "./assemble.js";
-
-/**
- * L3 直出路径共享的 profile 装配闸门（评审 P1）
- *
- * fastpath / troubleshoot 排在 answer 之前，命中即直接产出回答并让 answer 跳过。若只有
- * answer 做 ensureAssembled 校验，则 profile 装配错误（overlay 放开闸门、KB collection
- * 缺失、role 解析失败等）下 fastpath / troubleshoot 仍可能带病作答，违背“profile 错误
- * 阻断作答 / 闸门只准收紧”的纪律。故所有会直接产出回答的 recipe 在执行实际逻辑前都调用本闸门。
- *
- * 返回：
- *   - RecipeResult —— 存在装配 error：阻断作答的 agent_failure 静默（tracker:false，
- *     留痕与否交 on_action 按策略裁决）；
- *   - RecipeResult —— 本次发生写入（wrote 非空）：配置刚被自动更新，同一进程内
- *     已加载的 workflow/role 可能仍是旧值，阻断作答并提示重启（正常 npm 入口已在
- *     进程启动前完成装配，不会走到这里；这是直接执行 aitable-workflow run 的兜底）；
- *   - null —— 无 error 且无写入，放行。
- *
- * ensureAssembled 按 configDir 进程内缓存，重复调用（同一消息经 fastpath→troubleshoot→answer
- * 多步）无额外磁盘开销。
- */
-export function profileAssembleGuard(
-  ctx: RecipeContext,
-  log: (msg: string) => void,
-): RecipeResult | null {
-  const asm = ensureAssembled(ctx.configDir, log);
-  const errors = asm.issues.filter((i) => i.level === "error");
-  if (errors.length === 0 && asm.wrote.length === 0) return null;
-  if (errors.length > 0) {
-    log(`profile 校验失败（${errors.length} 个错误），阻断作答`);
-    return {
-      status: "success",
-      output: {
-        action: "agent_failure",
-        answer: "",
-        reason: `profile 校验失败: ${errors[0]!.message}`,
-      },
-      tracker: false, // 留痕与否由 on_action 按 agent_failure 策略裁决
-      logs: ["profile 校验失败 → 阻断作答", errors[0]!.message],
-    };
-  }
-  // 本次装配发生了写入：不在同一进程内带着刚改写的配置继续运行
-  log(`profile 配置已自动更新（${asm.wrote.length} 个文件），请重启进程后继续（推荐用 npm run run / npm run setup 入口）`);
-  return {
-    status: "success",
-    output: {
-      action: "agent_failure",
-      answer: "",
-      reason: "配置已自动更新，需重启进程后生效",
-    },
-    tracker: false,
-    logs: ["装配发生写入 → 阻断本次作答，请重启"],
-  };
-}

package/templates/support-qa/lib/send-failure-guard.ts

@@ -1,59 +0,0 @@
-import { createHash } from "node:crypto";
-
-/**
- * 发送失败留痕去重（send_failure guard）
- *
- * 背景：发送失败会被步骤重试 + 外层重投多次驱动（真实案例：同一条待发内容、同一
- * "无可用 sessionWebhook" 原因，在 1.5 分钟内写了 18 条 send_failed）。失败重试本身是
- * 对的，但每次尝试都往短期记忆里追加一条，会把同一个故障放大成十几条同质记录：
- * 复盘的 sendFailedCount 被严重虚高，学习语料里也全是重复噪声。
- *
- * 方案：按「群 + 待发内容 + 失败原因」做窗口内去重——同一故障只记第一次；窗口过后
- * 若仍失败则再记一次（作为"故障持续"的新信号）。不同内容或不同原因永不互相吞掉。
- *
- * 注意：这里去重的只是「留痕」，不改变发送重试与 step 失败语义。
- */
-
-const VAR_KEY = "send_failure_marks";
-const CAPACITY = 50;
-const TTL_MS = 10 * 60 * 1000;
-
-type Mark = { h: string; ts: number };
-
-function loadList(get: (key: string) => unknown): Mark[] {
-  const raw = get(VAR_KEY);
-  if (!Array.isArray(raw)) return [];
-  const now = Date.now();
-  return (raw as Mark[]).filter((m) => m && typeof m.h === "string" && now - m.ts <= TTL_MS);
-}
-
-export function sendFailureFingerprint(args: { conversationId: string; content: string; reason: string }): string {
-  const normalized = [
-    args.conversationId,
-    args.content.replace(/\s+/g, "").slice(0, 300),
-    args.reason.replace(/\s+/g, "").slice(0, 200),
-  ].join("|");
-  return createHash("sha1").update(normalized).digest("hex");
-}
-
-/**
- * 是否应为本次发送失败写短期记忆。
- * 首次出现 → 登记并返回 true；窗口内同签名重试 → 返回 false（调用方只记日志）。
- */
-export function shouldRecordSendFailure(
-  get: (key: string) => unknown,
-  set: (key: string, value: unknown) => void,
-  args: { conversationId: string; content: string; reason: string },
-): boolean {
-  const h = sendFailureFingerprint(args);
-  const list = loadList(get);
-  if (list.some((m) => m.h === h)) {
-    // 仍写回裁剪后的列表：顺带完成 TTL 清理，避免只读路径让过期项常驻
-    set(VAR_KEY, list);
-    return false;
-  }
-  list.push({ h, ts: Date.now() });
-  while (list.length > CAPACITY) list.shift();
-  set(VAR_KEY, list);
-  return true;
-}