@ai-setting/roy-agent-core 1.7.76 → 1.7.85

package/dist/shared/@ai-setting/roy-agent-core-m3vjepzz.js

@@ -0,0 +1,544 @@
+import {
+  getEnvContextOrEmpty,
+  init_env_context
+} from "./roy-agent-core-7cbpmk4q.js";
+
+// src/env/event-source/wecom-respond-registry.ts
+init_env_context();
+import { z } from "zod";
+
+// src/env/event-source/wecom-cli-sender.ts
+import { spawn } from "child_process";
+var WECOM_CLI_SEND_TIMEOUT_MS = 15000;
+var WECOM_CLI_RESOLVE_TIMEOUT_MS = 15000;
+function resolveWecomCliBinary() {
+  const fromEnv = process.env.WECOM_CLI_BIN;
+  if (typeof fromEnv === "string" && fromEnv.trim().length > 0) {
+    return fromEnv.trim();
+  }
+  return "wecom-cli";
+}
+function buildWecomCliSendArgs(input) {
+  return [
+    "message",
+    "aibot",
+    "send",
+    "--chat-id",
+    input.chatId,
+    "--msg-type",
+    "markdown",
+    "--markdown",
+    JSON.stringify({ content: input.content })
+  ];
+}
+function buildWecomCliResolveArgs(keywords) {
+  return ["contact", "users", "search", "--set", `keywords=${keywords}`];
+}
+function parseWecomCliResult(stdout) {
+  const text = (stdout ?? "").trim();
+  if (!text)
+    return { ok: false, error: "empty stdout" };
+  const start = text.indexOf("{");
+  const jsonText = start >= 0 ? text.slice(start) : text;
+  let parsed;
+  try {
+    parsed = JSON.parse(jsonText);
+  } catch {
+    return { ok: false, error: `non-JSON stdout: ${text.slice(0, 200)}` };
+  }
+  const obj = parsed;
+  if (obj?.error) {
+    const code = obj.error.code ?? "?";
+    const message = obj.error.message ?? obj.error.type ?? "unknown error";
+    return { ok: false, error: `[code=${code}] ${message}` };
+  }
+  if (obj?.success === true)
+    return { ok: true };
+  return { ok: true };
+}
+function parseWecomCliUserSearch(stdout, fallback) {
+  const text = (stdout ?? "").trim();
+  const start = text.indexOf("{");
+  if (start < 0)
+    return fallback;
+  try {
+    const parsed = JSON.parse(text.slice(start));
+    const userid = parsed?.users?.[0]?.userid;
+    return typeof userid === "string" && userid.length > 0 ? userid : fallback;
+  } catch {
+    return fallback;
+  }
+}
+function runCli(args, timeoutMs) {
+  return new Promise((resolve) => {
+    let settled = false;
+    let stdout = "";
+    let stderr = "";
+    const finish = (code) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      resolve({ stdout, stderr, code });
+    };
+    let proc;
+    try {
+      proc = spawn(resolveWecomCliBinary(), args, {
+        shell: false,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+    } catch (err) {
+      resolve({
+        stdout: "",
+        stderr: err instanceof Error ? err.message : String(err),
+        code: null
+      });
+      return;
+    }
+    const timer = setTimeout(() => {
+      try {
+        proc.kill("SIGKILL");
+      } catch {}
+      finish(null);
+    }, timeoutMs);
+    timer.unref?.();
+    proc.stdout?.on("data", (d) => {
+      stdout += d.toString();
+    });
+    proc.stderr?.on("data", (d) => {
+      stderr += d.toString();
+    });
+    proc.on("error", (err) => {
+      stderr += err.message;
+      finish(null);
+    });
+    proc.on("close", (code) => finish(code));
+  });
+}
+var cliChatIdCache = new Map;
+async function resolveWecomCliChatId(userId) {
+  const key = userId.trim();
+  if (!key)
+    return key;
+  const cached = cliChatIdCache.get(key);
+  if (cached)
+    return cached;
+  const { stdout } = await runCli(buildWecomCliResolveArgs(key), WECOM_CLI_RESOLVE_TIMEOUT_MS);
+  const resolved = parseWecomCliUserSearch(stdout, key);
+  if (resolved !== key)
+    cliChatIdCache.set(key, resolved);
+  return resolved;
+}
+async function sendWecomCliMarkdown(input) {
+  const content = input.content ?? "";
+  if (!input.chatId || content.trim().length === 0) {
+    return { ok: false, error: "empty chatId or content" };
+  }
+  const { stdout, stderr, code } = await runCli(buildWecomCliSendArgs({ chatId: input.chatId, content }), input.timeoutMs ?? WECOM_CLI_SEND_TIMEOUT_MS);
+  const parsed = parseWecomCliResult(stdout);
+  if (parsed.ok)
+    return parsed;
+  const detail = stderr.trim() ? `${parsed.error} | stderr: ${stderr.trim().slice(0, 200)}` : parsed.error;
+  return { ok: false, error: `${detail} (exit=${code ?? "null"})` };
+}
+
+// src/env/event-source/wecom-card-builder.ts
+var WecomCardActionKey = {
+  VIEW: "task_view",
+  MARK_DONE: "task_mark_done",
+  REOPEN: "task_reopen"
+};
+function wecomCardTaskIdForTask(taskId) {
+  return `roy-task-${taskId}`;
+}
+var cardSeq = 0;
+function newWecomCardTaskId(taskId) {
+  cardSeq = (cardSeq + 1) % 1e6;
+  const rand = Math.random().toString(36).slice(2, 8);
+  return `${wecomCardTaskIdForTask(taskId)}-${cardSeq}-${rand}`;
+}
+function formatTs(iso) {
+  try {
+    const d = new Date(iso);
+    if (isNaN(d.getTime()))
+      return iso;
+    const pad = (n) => String(n).padStart(2, "0");
+    return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ` + `${pad(d.getHours())}:${pad(d.getMinutes())}`;
+  } catch {
+    return iso;
+  }
+}
+function clip(text, max) {
+  if (!text)
+    return "";
+  const t = text.trim();
+  return t.length > max ? `${t.slice(0, max)}…` : t;
+}
+function shortMilestoneValue(text) {
+  if (!text)
+    return "";
+  const t = text.trim();
+  const colonIdx = t.indexOf("：");
+  const head = colonIdx > 0 && colonIdx <= 20 ? t.slice(0, colonIdx).trim() : t;
+  if (head.length <= MAX_HORIZONTAL_VALUE)
+    return head;
+  return clipWord(head, MAX_HORIZONTAL_VALUE);
+}
+function clipWord(text, max) {
+  if (!text)
+    return "";
+  const t = text.trim();
+  if (t.length <= max)
+    return t;
+  let cut = t.slice(0, max - 1);
+  const lastSpace = cut.lastIndexOf(" ");
+  if (lastSpace > max * 0.4)
+    return `${cut.slice(0, lastSpace).trimEnd()}…`;
+  const cjkBoundary = findCjkAsciiBoundary(cut);
+  if (cjkBoundary > max * 0.4)
+    return `${cut.slice(0, cjkBoundary).trimEnd()}…`;
+  return cut.slice(0, max - 1);
+}
+function findCjkAsciiBoundary(text) {
+  const isCjk = (ch) => /[一-鿿぀-ヿ가-힯]/.test(ch);
+  const isAsciiAlnum = (ch) => /[A-Za-z0-9]/.test(ch);
+  for (let i = text.length - 1;i > 0; i--) {
+    const prev = text[i - 1];
+    const cur = text[i];
+    if (isCjk(prev) !== isAsciiAlnum(cur) && isCjk(cur) !== isAsciiAlnum(prev)) {
+      if (isCjk(prev) && isAsciiAlnum(cur) || isAsciiAlnum(prev) && isCjk(cur)) {
+        return i;
+      }
+    }
+  }
+  return -1;
+}
+var MAX_TIMELINE_LINES = 8;
+var MAX_HORIZONTAL_ROWS = 6;
+var MAX_HORIZONTAL_VALUE = 26;
+function buildWecomTextNoticeCard(input) {
+  const progressPct = `${Math.max(0, Math.min(100, Math.round(input.progress ?? 0)))}%`;
+  const sorted = [...input.milestones].slice(-MAX_TIMELINE_LINES).reverse();
+  const timelineRows = sorted.slice(0, MAX_HORIZONTAL_ROWS - 1).map((m) => ({
+    keyname: formatTs(m.timestamp).slice(11),
+    value: shortMilestoneValue(m.title)
+  }));
+  const horizontal = [
+    { keyname: "状态", value: clip(input.statusLabel, MAX_HORIZONTAL_VALUE) },
+    ...timelineRows
+  ];
+  const latest = sorted[0];
+  const quoteLine = latest ? `${formatTs(latest.timestamp)} — ${clipWord(latest.title, 80)}${latest.description ? `：${clipWord(latest.description, 80)}` : ""}` : "";
+  const latestSummary = latest && latest.title ? `${formatTs(latest.timestamp)} ${clip(latest.title, 140)}` : undefined;
+  const subTitle = input.terminal ? `任务${input.statusLabel.replace(/^[^\u4e00-\u9fa5A-Za-z]*/, "")} · 详见会话` : latestSummary;
+  return {
+    card_type: "text_notice",
+    main_title: {
+      title: `\uD83D\uDCCB Task #${input.taskId} · ${clip(input.title, 60)}`,
+      desc: clip(input.description, 80) || undefined
+    },
+    emphasis_content: {
+      title: progressPct,
+      desc: "进度"
+    },
+    sub_title_text: subTitle,
+    horizontal_content_list: horizontal,
+    quote_area: {
+      type: 0,
+      title: "最新进展",
+      quote_text: quoteLine || "（暂无操作记录）"
+    },
+    card_action: { type: 0 }
+  };
+}
+var MAX_BUTTONS = 6;
+var MAX_BUTTON_TEXT = 10;
+function buildWecomButtonInteractionCard(input) {
+  const notice = buildWecomTextNoticeCard({
+    taskId: input.taskId,
+    title: input.title,
+    statusLabel: input.statusLabel,
+    progress: input.progress,
+    description: input.description,
+    changeSummary: input.changeSummary,
+    milestones: input.milestones ?? []
+  });
+  const buttons = (input.buttons ?? []).slice(0, MAX_BUTTONS).map((b) => ({
+    text: clip(b.text, MAX_BUTTON_TEXT),
+    style: b.style ?? 1,
+    key: b.key
+  }));
+  return {
+    card_type: "button_interaction",
+    main_title: notice.main_title,
+    sub_title_text: notice.sub_title_text,
+    horizontal_content_list: notice.horizontal_content_list,
+    quote_area: notice.quote_area,
+    button_list: buttons,
+    card_action: { type: 0 },
+    task_id: input.cardTaskId ?? newWecomCardTaskId(input.taskId)
+  };
+}
+function buildWecomSendCardFrame(input) {
+  const reqId = input.reqId && input.reqId.trim() ? input.reqId.trim() : `aibot_send_msg_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
+  return {
+    cmd: "aibot_send_msg",
+    headers: { req_id: reqId },
+    body: {
+      chatid: input.chatId,
+      chat_type: input.chatType === "group" ? 2 : 1,
+      msgtype: "template_card",
+      template_card: input.card
+    }
+  };
+}
+var MAX_UPDATE_TITLE = 60;
+function buildUpdateMainTitle(statusLabel, taskNumber, taskTitle) {
+  const segments = [];
+  if (taskNumber !== undefined && Number.isFinite(taskNumber)) {
+    segments.push(`Task #${taskNumber}`);
+  }
+  if (taskTitle) {
+    segments.push(clip(taskTitle, MAX_UPDATE_TITLE));
+  }
+  segments.push(statusLabel);
+  return segments.length > 1 ? `\uD83D\uDCCB ${segments.join(" · ")}` : `\uD83D\uDCCB ${statusLabel}`;
+}
+function buildWecomCardUpdateFrame(input) {
+  const reqId = (input.reqId ?? "").trim();
+  if (!reqId) {
+    throw new Error("buildWecomCardUpdateFrame: req_id is required " + "(update must reference the template_card_event frame)");
+  }
+  const buttons = (input.buttonOverrides ?? []).slice(0, MAX_BUTTONS).map((b) => ({
+    text: clip(b.text, MAX_BUTTON_TEXT),
+    style: b.style ?? 1,
+    key: b.key
+  }));
+  const sorted = [...input.timeline ?? []].reverse();
+  const timelineRows = sorted.slice(0, MAX_HORIZONTAL_ROWS).map((m) => ({
+    keyname: formatTs(m.timestamp).slice(11),
+    value: shortMilestoneValue(m.title)
+  }));
+  const total = sorted.length;
+  const subTitle = total > 0 ? total > MAX_HORIZONTAL_ROWS ? `共 ${total} 条操作记录，显示最近 ${MAX_HORIZONTAL_ROWS} 条（最新在顶部）` : `共 ${total} 条操作记录（最新在顶部）` : undefined;
+  return {
+    cmd: "aibot_respond_update_msg",
+    headers: { req_id: reqId },
+    body: {
+      response_type: "update_template_card",
+      template_card: {
+        card_type: "button_interaction",
+        main_title: {
+          title: buildUpdateMainTitle(input.statusLabel, input.taskNumber, input.taskTitle),
+          desc: input.note ? clip(input.note, 80) : undefined
+        },
+        sub_title_text: subTitle,
+        horizontal_content_list: timelineRows,
+        button_list: buttons,
+        task_id: String(input.taskId)
+      }
+    }
+  };
+}
+
+// src/env/event-source/wecom-respond-registry.ts
+var registry = new Map;
+function registerWecomRespondTarget(sourceId, target) {
+  registry.set(sourceId, target);
+}
+function unregisterWecomRespondTarget(sourceId) {
+  registry.delete(sourceId);
+}
+function getWecomRespondTarget(sourceId) {
+  return registry.get(sourceId);
+}
+function __resetWecomRespondRegistryForTest() {
+  registry.clear();
+}
+async function sendWecomReply(input) {
+  const content = input.content ?? "";
+  if (content.trim().length === 0) {
+    return { ok: false, error: "empty content" };
+  }
+  const errors = [];
+  if (input.reqId) {
+    const target = getWecomRespondTarget(input.sourceId);
+    if (target) {
+      const wsErr = target.respond(input.reqId, {
+        msgtype: "markdown",
+        markdown: { content }
+      });
+      if (!wsErr)
+        return { ok: true, channel: "ws" };
+      errors.push(`ws: ${wsErr.message}`);
+    } else {
+      errors.push(`ws: no instance registered for sourceId=${input.sourceId}`);
+    }
+  } else {
+    errors.push("ws: no req_id");
+  }
+  if (input.rawChatId) {
+    try {
+      const chatId = await resolveWecomCliChatId(input.rawChatId);
+      const cliResult = await sendWecomCliMarkdown({ chatId, content });
+      if (cliResult.ok)
+        return { ok: true, channel: "cli" };
+      errors.push(`cli: ${cliResult.error}`);
+    } catch (err) {
+      errors.push(`cli: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  } else {
+    errors.push("cli: no chatId");
+  }
+  return { ok: false, error: errors.join(" | ") };
+}
+async function sendWecomTemplateCard(input) {
+  if (!input.chatId) {
+    return { ok: false, error: "no chatId" };
+  }
+  const target = getWecomRespondTarget(input.sourceId);
+  if (!target) {
+    return {
+      ok: false,
+      error: `no instance registered for sourceId=${input.sourceId}`
+    };
+  }
+  if (typeof target.sendCmd !== "function") {
+    return {
+      ok: false,
+      error: `registered instance has no sendCmd (old bridge?)`
+    };
+  }
+  const frame = buildWecomSendCardFrame({
+    chatId: input.chatId,
+    chatType: input.chatType,
+    card: input.card
+  });
+  try {
+    const err = target.sendCmd(frame.cmd, frame.body);
+    if (err)
+      return { ok: false, error: err.message };
+    return { ok: true, channel: "ws" };
+  } catch (err) {
+    return {
+      ok: false,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+var wecomRespondTool = {
+  name: "wecom_respond",
+  description: "Reply to the WeCom (企业微信) user. Primary path is the official wecom-cli " + "(message aibot send, markdown); WS long-connection frame is used as fallback. " + "This is the ONLY outbound channel for WeCom messages.",
+  parameters: z.object({
+    content: z.string().describe("Reply content (markdown supported)"),
+    chat_id: z.string().optional().describe("Target chat id (single chat = peer userid, group = chatid). " + "Defaults to the current event's chatId/senderId."),
+    req_id: z.string().optional().describe("Original message frame req_id (optional; used for WS fallback only). " + "Defaults to the current event metadata.reqId.")
+  }),
+  metadata: {
+    category: "messaging",
+    tags: ["wecom", "reply", "im"],
+    version: "2.0.0"
+  },
+  execute: async (args, _ctx) => {
+    const { content } = args;
+    let sourceId;
+    let eventChatId;
+    let eventReqId;
+    try {
+      const ctx = getEnvContextOrEmpty();
+      sourceId = typeof ctx.sourceId === "string" ? ctx.sourceId : undefined;
+      const meta = ctx.envEvent?.metadata;
+      const cid = meta?.chatId;
+      if (typeof cid === "string" && cid.length > 0)
+        eventChatId = cid;
+      const rid = meta?.reqId;
+      if (typeof rid === "string" && rid.length > 0)
+        eventReqId = rid;
+    } catch {}
+    const chatId = args.chat_id?.trim() || eventChatId;
+    const reqId = args.req_id?.trim() || eventReqId;
+    if (!chatId) {
+      return {
+        success: false,
+        output: "",
+        error: "wecom_respond: cannot resolve chat_id (no explicit chat_id and no EnvContext event chatId)."
+      };
+    }
+    if (!sourceId) {
+      sourceId = "unknown";
+    }
+    const startedAt = Date.now();
+    const result = await sendWecomReply({
+      sourceId,
+      rawChatId: chatId,
+      reqId,
+      content
+    });
+    if (!result.ok) {
+      return {
+        success: false,
+        output: "",
+        error: `wecom_respond: send failed: ${result.error ?? "unknown"}`
+      };
+    }
+    markWecomReplySent();
+    return {
+      success: true,
+      output: `Reply sent to WeCom via ${result.channel} ` + `(chat_id=${chatId}, ${content.length} chars)`,
+      metadata: {
+        execution_time_ms: Date.now() - startedAt,
+        channel: result.channel,
+        chat_id: chatId
+      }
+    };
+  }
+};
+var REPLY_SENT_KEY = "__wecomReplySent";
+function replySentBag(explicit) {
+  if (explicit)
+    return explicit;
+  try {
+    const ctx = getEnvContextOrEmpty();
+    return ctx.agentContext ??= {};
+  } catch {
+    return {};
+  }
+}
+function markWecomReplySent(explicitBag) {
+  replySentBag(explicitBag)[REPLY_SENT_KEY] = true;
+}
+function wasWecomReplySent(explicitBag) {
+  return replySentBag(explicitBag)[REPLY_SENT_KEY] === true;
+}
+function __resetWecomReplySentForTest(explicitBag) {
+  delete replySentBag(explicitBag)[REPLY_SENT_KEY];
+}
+var WECOM_EVENT_TYPE = "event-source.event.wecom-cli";
+async function autoReplyWecomTurn(envEvent, finalText) {
+  const evt = envEvent;
+  if (evt?.type !== WECOM_EVENT_TYPE) {
+    return { skipped: true, reason: "not a wecom event" };
+  }
+  const text = (finalText ?? "").trim();
+  if (!text)
+    return { skipped: true, reason: "empty final text" };
+  if (wasWecomReplySent()) {
+    return { skipped: true, reason: "already replied via tool" };
+  }
+  const meta = evt.metadata ?? {};
+  const chatId = typeof meta.chatId === "string" && meta.chatId || typeof meta.senderId === "string" && meta.senderId || "";
+  const sourceId = typeof meta.sourceId === "string" && meta.sourceId || "unknown";
+  const reqId = typeof meta.reqId === "string" ? meta.reqId : undefined;
+  if (!chatId) {
+    return { skipped: true, reason: "no chatId in event metadata" };
+  }
+  const r = await sendWecomReply({
+    sourceId,
+    rawChatId: chatId,
+    reqId,
+    content: text
+  });
+  return { skipped: false, ok: r.ok, channel: r.channel, error: r.error };
+}
+
+export { WecomCardActionKey, buildWecomTextNoticeCard, buildWecomButtonInteractionCard, buildWecomCardUpdateFrame, registerWecomRespondTarget, unregisterWecomRespondTarget, getWecomRespondTarget, __resetWecomRespondRegistryForTest, sendWecomReply, sendWecomTemplateCard, wecomRespondTool, markWecomReplySent, wasWecomReplySent, __resetWecomReplySentForTest, autoReplyWecomTurn };

package/dist/shared/@ai-setting/{roy-agent-core-zycadbpx.js → roy-agent-core-p6ks90tb.js}

@@ -2,7 +2,7 @@ import {
   createAutoTaskPlugin,
   createLayaDecisionPlugin,
   registerLayaCompletionTaskHook
-} from "./roy-agent-core-ghnagzrh.js";
+} from "./roy-agent-core-b31v3qpv.js";
 import {
   TaskHookPoints
 } from "./roy-agent-core-1pg0fepg.js";

package/dist/shared/@ai-setting/{roy-agent-core-ntq0gz7q.js → roy-agent-core-q813vafd.js}

@@ -1,6 +1,6 @@
 import {
   init_sqlite_task_store
-} from "./roy-agent-core-abqhkbn3.js";
+} from "./roy-agent-core-ezvpreqz.js";
 
 // src/env/task/storage/index.ts
 init_sqlite_task_store();

package/dist/shared/@ai-setting/{roy-agent-core-z43aj03k.js → roy-agent-core-qk9hd89p.js}

@@ -9,7 +9,7 @@ import {
 import {
   BackgroundTaskManager,
   createDelegateTool
-} from "./roy-agent-core-aa2j7bk9.js";
+} from "./roy-agent-core-cha0jc7n.js";
 import {
   TaskEntityEventTypes
 } from "./roy-agent-core-8gxth0eh.js";
@@ -37,7 +37,7 @@ import {
 import {
   SQLiteTaskStore,
   getDefaultTaskDbPath
-} from "./roy-agent-core-abqhkbn3.js";
+} from "./roy-agent-core-ezvpreqz.js";
 import {
   TaskHookPoints
 } from "./roy-agent-core-1pg0fepg.js";
@@ -471,6 +471,15 @@ class TaskComponent extends BaseComponent {
   async getTaskIdBySessionId(sessionId) {
     return this.store.getTaskIdBySessionId(sessionId);
   }
+  async getTaskIdsBySessionId(sessionId) {
+    const store = this.store;
+    if (typeof store.getTaskIdsBySessionId === "function") {
+      const ids = await store.getTaskIdsBySessionId(sessionId);
+      return Array.isArray(ids) ? ids : [];
+    }
+    const first = await this.store.getTaskIdBySessionId(sessionId);
+    return typeof first === "number" ? [first] : [];
+  }
   async getTaskWithOperations(id) {
     const task = await this.store.getTask(id);
     if (!task)
@@ -676,6 +685,16 @@ class TaskComponent extends BaseComponent {
   async listOperations(options) {
     return this.store.listOperations(options);
   }
+  async listOperationsFresh(options) {
+    const store = this.store;
+    if (typeof store.listOperationsFresh === "function") {
+      return await store.listOperationsFresh(options);
+    }
+    if (typeof store.invalidateOperationsCache === "function") {
+      store.invalidateOperationsCache(options.taskId);
+    }
+    return await this.store.listOperations(options);
+  }
   getTagService() {
     return this.tagService;
   }