chainlesschain 0.162.155 → 0.162.156

package/src/lib/agent-notify.js

@@ -0,0 +1,66 @@
+/**
+ * agent-notify — shared backing for the `notify` agent tool + `cc agenda`
+ * monitor firing (gap-analysis 第四阶段 #3).
+ *
+ * Fans a notification out over the user's configured multi-channel notifiers
+ * (Telegram / WeCom / DingTalk / Feishu, via NotificationManager.fromEnv) and,
+ * when a paired-device push descriptor exists, the mobile push bridge. Pure
+ * over injected deps so it is unit-testable without any network.
+ */
+
+import { NotificationManager } from "./notifiers/index.js";
+
+/**
+ * @param {{title:string, body?:string, level?:"info"|"success"|"failure"}} msg
+ * @param {{env?:object, manager?:object}} [deps]
+ * @returns {Promise<{delivered:string[], failed:string[], channels:number, results:Array}>}
+ */
+export async function sendAgentNotification(msg, deps = {}) {
+  const title = String(msg?.title || "").trim();
+  if (!title) throw new Error("notify requires a title");
+  const body = msg?.body ? String(msg.body) : "";
+  const level = ["info", "success", "failure"].includes(msg?.level)
+    ? msg.level
+    : "info";
+
+  const manager =
+    deps.manager ||
+    NotificationManager.fromEnv({ env: deps.env || process.env });
+  if (!manager.isConfigured) {
+    return {
+      delivered: [],
+      failed: [],
+      channels: 0,
+      results: [],
+      note: "No notification channels configured (set TELEGRAM_BOT_TOKEN / WECOM_WEBHOOK_URL / DINGTALK_WEBHOOK_URL / FEISHU_WEBHOOK_URL).",
+    };
+  }
+
+  const summary = {
+    taskId: msg?.taskId || null,
+    description: title,
+    detail: body,
+    message: body || title,
+    title,
+  };
+  const method =
+    level === "success"
+      ? "notifySuccess"
+      : level === "failure"
+        ? "notifyFailure"
+        : "notifyStart";
+  const results = await manager[method](summary);
+
+  const delivered = [];
+  const failed = [];
+  for (const r of results || []) {
+    if (r && r.ok !== false) delivered.push(r.channel);
+    else failed.push(r?.channel || "unknown");
+  }
+  return {
+    delivered,
+    failed,
+    channels: (manager.activeChannels || []).length,
+    results: results || [],
+  };
+}

package/src/lib/agent-schedule-store.js

@@ -0,0 +1,330 @@
+/**
+ * AgentScheduleStore — persistent backing for the agent-callable Monitor /
+ * Cron / Wakeup tools (gap-analysis 第四阶段 #3).
+ *
+ * A one-shot `cc agent` turn cannot itself keep a timer alive, so these tools
+ * PERSIST their intent to a JSONL store under
+ * `~/.chainlesschain/agent-schedule/<kind>.jsonl`; a supervising loop / cron
+ * (`cc agenda run`) reads due entries and acts. This mirrors how Claude Code's
+ * Monitor/CronCreate/ScheduleWakeup outlive a single turn.
+ *
+ * Three entry kinds share one store:
+ *   - wakeup   one-shot: run `prompt` (a `cc agent -p`) once at/after `dueAt`.
+ *   - cron     recurring: run `prompt` on a cron schedule; `nextAt` advances.
+ *   - monitor  recurring watch: run `command` (shell) every `intervalMs`;
+ *              fire the `notify` payload when `stopWhen` regex matches output.
+ *
+ * Pure over an injected clock + directory so it is fully unit-testable. Cron
+ * parsing is a compact 5-field evaluator (min hour dom mon dow) supporting
+ * `* , - /` — enough for the scheduling the agent actually asks for.
+ */
+
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { randomUUID } from "crypto";
+
+export const SCHEDULE_KINDS = Object.freeze(["wakeup", "cron", "monitor"]);
+
+export function agentScheduleDir(homedir = os.homedir()) {
+  return path.join(homedir, ".chainlesschain", "agent-schedule");
+}
+
+// ─── cron (5-field) ────────────────────────────────────────────────────────
+
+const CRON_RANGES = [
+  [0, 59], // minute
+  [0, 23], // hour
+  [1, 31], // day of month
+  [1, 12], // month
+  [0, 6], // day of week (0/7 = Sunday)
+];
+
+function parseCronField(field, [min, max]) {
+  const values = new Set();
+  for (const part of String(field).split(",")) {
+    const [rangePart, stepPart] = part.split("/");
+    const step = stepPart ? parseInt(stepPart, 10) : 1;
+    if (!Number.isFinite(step) || step < 1) {
+      throw new Error(`invalid cron step in "${field}"`);
+    }
+    let lo = min;
+    let hi = max;
+    if (rangePart !== "*" && rangePart !== "") {
+      const bounds = rangePart.split("-");
+      lo = parseInt(bounds[0], 10);
+      hi = bounds.length > 1 ? parseInt(bounds[1], 10) : lo;
+      if (!Number.isFinite(lo) || !Number.isFinite(hi)) {
+        throw new Error(`invalid cron range in "${field}"`);
+      }
+    }
+    for (let v = lo; v <= hi; v += step) {
+      if (v < min || v > max) throw new Error(`cron value out of range: ${v}`);
+      values.add(v);
+    }
+  }
+  return values;
+}
+
+/** Parse a 5-field cron expression into per-field value sets. Throws on junk. */
+export function parseCron(expr) {
+  const fields = String(expr).trim().split(/\s+/);
+  if (fields.length !== 5) {
+    throw new Error(
+      `cron expression must have 5 fields (min hour dom mon dow), got ${fields.length}`,
+    );
+  }
+  return fields.map((field, i) => parseCronField(field, CRON_RANGES[i]));
+}
+
+function cronMatches(sets, date) {
+  const dow = date.getDay(); // 0-6, Sun=0
+  return (
+    sets[0].has(date.getMinutes()) &&
+    sets[1].has(date.getHours()) &&
+    sets[2].has(date.getDate()) &&
+    sets[3].has(date.getMonth() + 1) &&
+    (sets[4].has(dow) || (sets[4].has(7) && dow === 0))
+  );
+}
+
+/**
+ * Next epoch-ms at which `expr` fires strictly after `fromMs` (local time,
+ * minute granularity). Scans up to ~366 days then gives up (returns null) so a
+ * never-matching expression can't loop forever.
+ */
+export function nextCronTime(expr, fromMs) {
+  const sets = parseCron(expr);
+  const cursor = new Date(fromMs);
+  cursor.setSeconds(0, 0);
+  cursor.setMinutes(cursor.getMinutes() + 1);
+  const limit = 366 * 24 * 60;
+  for (let i = 0; i < limit; i += 1) {
+    if (cronMatches(sets, cursor)) return cursor.getTime();
+    cursor.setMinutes(cursor.getMinutes() + 1);
+  }
+  return null;
+}
+
+// ─── store ───────────────────────────────────────────────────────────────
+
+export class AgentScheduleStore {
+  constructor({ dir = null, now = () => Date.now() } = {}) {
+    this.dir = dir || agentScheduleDir();
+    this._now = typeof now === "function" ? now : () => now;
+  }
+
+  _file(kind) {
+    return path.join(this.dir, `${kind}.jsonl`);
+  }
+
+  _ensureDir() {
+    fs.mkdirSync(this.dir, { recursive: true, mode: 0o700 });
+  }
+
+  _readAll(kind) {
+    let raw;
+    try {
+      raw = fs.readFileSync(this._file(kind), "utf-8");
+    } catch {
+      return [];
+    }
+    const entries = [];
+    for (const line of raw.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      try {
+        entries.push(JSON.parse(trimmed));
+      } catch {
+        // Skip a corrupt line rather than throwing — one bad append must not
+        // poison the whole store (per-row resilience, like the JSON.parse sweep).
+      }
+    }
+    return entries;
+  }
+
+  _writeAll(kind, entries) {
+    this._ensureDir();
+    const body = entries.map((entry) => JSON.stringify(entry)).join("\n");
+    fs.writeFileSync(this._file(kind), body ? body + "\n" : "", {
+      encoding: "utf-8",
+      mode: 0o600,
+    });
+  }
+
+  // ── create ──────────────────────────────────────────────────────────────
+
+  scheduleWakeup({ prompt, delayMs = 0, dueAt = null, label = null } = {}) {
+    if (!prompt || typeof prompt !== "string") {
+      throw new Error("wakeup requires a prompt");
+    }
+    const now = this._now();
+    const entry = {
+      id: randomUUID(),
+      kind: "wakeup",
+      prompt,
+      label: label || null,
+      dueAt:
+        dueAt != null ? Number(dueAt) : now + Math.max(0, Number(delayMs) || 0),
+      createdAt: now,
+      status: "pending",
+    };
+    const entries = this._readAll("wakeup");
+    entries.push(entry);
+    this._writeAll("wakeup", entries);
+    return entry;
+  }
+
+  createCron({ prompt, cron, label = null } = {}) {
+    if (!prompt || typeof prompt !== "string") {
+      throw new Error("cron requires a prompt");
+    }
+    const now = this._now();
+    const nextAt = nextCronTime(cron, now); // validates the expression too
+    if (nextAt == null) {
+      throw new Error(`cron "${cron}" has no upcoming match`);
+    }
+    const entry = {
+      id: randomUUID(),
+      kind: "cron",
+      prompt,
+      cron,
+      label: label || null,
+      nextAt,
+      createdAt: now,
+      lastRunAt: null,
+      runs: 0,
+      status: "active",
+    };
+    const entries = this._readAll("cron");
+    entries.push(entry);
+    this._writeAll("cron", entries);
+    return entry;
+  }
+
+  createMonitor({
+    command,
+    intervalMs,
+    stopWhen = null,
+    notify = null,
+    maxChecks = null,
+    label = null,
+  } = {}) {
+    if (!command || typeof command !== "string") {
+      throw new Error("monitor requires a command");
+    }
+    const interval = Math.max(1000, Number(intervalMs) || 60000);
+    if (stopWhen != null) {
+      // Validate the regex up-front so a bad pattern errors at creation, not
+      // silently at the first check.
+      // eslint-disable-next-line no-new
+      new RegExp(stopWhen);
+    }
+    const now = this._now();
+    const entry = {
+      id: randomUUID(),
+      kind: "monitor",
+      command,
+      intervalMs: interval,
+      stopWhen: stopWhen || null,
+      notify: notify || null,
+      maxChecks: maxChecks != null ? Number(maxChecks) : null,
+      label: label || null,
+      nextAt: now + interval,
+      createdAt: now,
+      checks: 0,
+      status: "active",
+    };
+    const entries = this._readAll("monitor");
+    entries.push(entry);
+    this._writeAll("monitor", entries);
+    return entry;
+  }
+
+  // ── query ─────────────────────────────────────────────────────────────────
+
+  list(kind = null) {
+    const kinds = kind ? [kind] : SCHEDULE_KINDS;
+    const out = [];
+    for (const k of kinds) out.push(...this._readAll(k));
+    return out;
+  }
+
+  /** Entries whose time has come (pending wakeup / active cron|monitor). */
+  due(kind = null, atMs = null) {
+    const now = atMs != null ? atMs : this._now();
+    return this.list(kind).filter((entry) => {
+      if (entry.kind === "wakeup") {
+        return entry.status === "pending" && entry.dueAt <= now;
+      }
+      return entry.status === "active" && entry.nextAt <= now;
+    });
+  }
+
+  cancel(id) {
+    for (const kind of SCHEDULE_KINDS) {
+      const entries = this._readAll(kind);
+      const idx = entries.findIndex((entry) => entry.id === id);
+      if (idx >= 0) {
+        const [removed] = entries.splice(idx, 1);
+        this._writeAll(kind, entries);
+        return removed;
+      }
+    }
+    return null;
+  }
+
+  // ── lifecycle mutations (used by `cc agenda run`) ──────────────────────────
+
+  /** Mark a one-shot wakeup fired (keeps history; due() skips it). */
+  markWakeupFired(id, atMs = null) {
+    return this._mutate("wakeup", id, (entry) => {
+      entry.status = "fired";
+      entry.firedAt = atMs != null ? atMs : this._now();
+    });
+  }
+
+  /** Advance a cron entry to its next fire time after running once. */
+  advanceCron(id, atMs = null) {
+    const now = atMs != null ? atMs : this._now();
+    return this._mutate("cron", id, (entry) => {
+      entry.lastRunAt = now;
+      entry.runs = (entry.runs || 0) + 1;
+      const next = nextCronTime(entry.cron, now);
+      if (next == null) {
+        entry.status = "exhausted";
+      } else {
+        entry.nextAt = next;
+      }
+    });
+  }
+
+  /**
+   * Record a monitor check. `matched` ends the monitor (done); otherwise it is
+   * re-armed for the next interval, or exhausted once maxChecks is hit.
+   */
+  recordMonitorCheck(id, { matched = false, atMs = null } = {}) {
+    const now = atMs != null ? atMs : this._now();
+    return this._mutate("monitor", id, (entry) => {
+      entry.checks = (entry.checks || 0) + 1;
+      entry.lastCheckAt = now;
+      if (matched) {
+        entry.status = "matched";
+        entry.matchedAt = now;
+      } else if (entry.maxChecks != null && entry.checks >= entry.maxChecks) {
+        entry.status = "exhausted";
+      } else {
+        entry.nextAt = now + entry.intervalMs;
+      }
+    });
+  }
+
+  _mutate(kind, id, fn) {
+    const entries = this._readAll(kind);
+    const entry = entries.find((e) => e.id === id);
+    if (!entry) return null;
+    fn(entry);
+    this._writeAll(kind, entries);
+    return entry;
+  }
+}

package/src/runtime/agent-core.js

@@ -3010,6 +3010,100 @@ async function executeToolInner(
       }
     }
 
+    case "notify": {
+      try {
+        const { sendAgentNotification } =
+          await import("../lib/agent-notify.js");
+        const outcome = await sendAgentNotification({
+          title: args.title,
+          body: args.body,
+          level: args.level,
+        });
+        return attachDescriptor(outcome);
+      } catch (err) {
+        return attachDescriptor({ error: `notify failed: ${err.message}` });
+      }
+    }
+
+    case "schedule": {
+      try {
+        const { AgentScheduleStore } =
+          await import("../lib/agent-schedule-store.js");
+        const { parseDuration } = await import("../lib/loop.js");
+        const store = new AgentScheduleStore();
+        const action = String(args.action || "").toLowerCase();
+        if (action === "wakeup") {
+          if (!args.prompt) {
+            return attachDescriptor({
+              error: "schedule wakeup requires a prompt",
+            });
+          }
+          const delayMs = args.delay ? parseDuration(args.delay) : 0;
+          const entry = store.scheduleWakeup({
+            prompt: args.prompt,
+            delayMs,
+            label: args.label || null,
+          });
+          return attachDescriptor({
+            scheduled: entry,
+            hint: "Run `cc agenda run` (e.g. via cron or `cc loop`) to fire due entries.",
+          });
+        }
+        if (action === "cron") {
+          if (!args.prompt || !args.cron) {
+            return attachDescriptor({
+              error: "schedule cron requires a prompt and a cron expression",
+            });
+          }
+          const entry = store.createCron({
+            prompt: args.prompt,
+            cron: args.cron,
+            label: args.label || null,
+          });
+          return attachDescriptor({ scheduled: entry });
+        }
+        if (action === "monitor") {
+          if (!args.command) {
+            return attachDescriptor({
+              error: "schedule monitor requires a command",
+            });
+          }
+          const intervalMs = args.interval
+            ? parseDuration(args.interval)
+            : 60000;
+          const entry = store.createMonitor({
+            command: args.command,
+            intervalMs,
+            stopWhen: args.stop_when || null,
+            notify: args.notify_title ? { title: args.notify_title } : null,
+            maxChecks: args.max_checks ?? null,
+            label: args.label || null,
+          });
+          return attachDescriptor({ scheduled: entry });
+        }
+        if (action === "list") {
+          return attachDescriptor({ entries: store.list() });
+        }
+        if (action === "cancel") {
+          if (!args.id) {
+            return attachDescriptor({
+              error: "schedule cancel requires an id",
+            });
+          }
+          const removed = store.cancel(args.id);
+          return attachDescriptor({
+            cancelled: removed ? removed.id : null,
+            found: Boolean(removed),
+          });
+        }
+        return attachDescriptor({
+          error: `unknown schedule action "${args.action}". Valid: wakeup, cron, monitor, list, cancel.`,
+        });
+      } catch (err) {
+        return attachDescriptor({ error: `schedule failed: ${err.message}` });
+      }
+    }
+
     case "search_files": {
       // An explicit directory scopes the search to one root; otherwise span
       // cwd plus any --add-dir roots so cross-package searches find matches.
@@ -6342,6 +6436,16 @@ export function formatToolArgs(name, args) {
       return `[${args.role}] ${(args.task || "").substring(0, 60)}`;
     case "search_sessions":
       return `"${(args.query || "").substring(0, 60)}"`;
+    case "notify":
+      return `${args.level || "info"}: ${(args.title || "").substring(0, 50)}`;
+    case "schedule":
+      return args.action === "cron"
+        ? `cron ${args.cron || ""}`.trim()
+        : args.action === "monitor"
+          ? `monitor ${(args.command || "").substring(0, 40)}`.trim()
+          : args.action === "wakeup"
+            ? `wakeup +${args.delay || "0s"}`
+            : String(args.action || "");
     default:
       return JSON.stringify(args).substring(0, 60);
   }

package/src/runtime/coding-agent-contract-shared.cjs

@@ -849,6 +849,110 @@ const CODING_AGENT_TOOL_CONTRACTS = Object.freeze([
       tags: ["tool:search_sessions", "contract:coding-agent", "tier:extension"],
     },
   },
+  {
+    name: "notify",
+    title: "Send Notification",
+    kind: "notify",
+    tier: "extension",
+    description:
+      "Push a notification to the user's configured channels (Telegram / WeCom / DingTalk / Feishu) and/or a paired mobile device. Use for long-running tasks: report completion, flag that you need a human decision, or surface an error. Best-effort: reports which channels delivered.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        title: { type: "string", description: "Short notification title" },
+        body: { type: "string", description: "Notification body text" },
+        level: {
+          type: "string",
+          enum: ["info", "success", "failure"],
+          description: "Severity (default: info)",
+        },
+      },
+      required: ["title"],
+    },
+    ...TOOL_POLICY_METADATA.notify,
+    permissions: {
+      level: "standard",
+      scopes: ["network:notify"],
+    },
+    telemetry: {
+      category: "notify",
+      tags: ["tool:notify", "contract:coding-agent", "tier:extension"],
+    },
+  },
+  {
+    name: "schedule",
+    title: "Schedule / Monitor",
+    kind: "schedule",
+    tier: "extension",
+    description:
+      "Set up work that outlives this turn (persisted for `cc agenda run` to execute). Actions: `wakeup` — run a prompt once after a delay; `cron` — run a prompt on a 5-field cron schedule; `monitor` — run a shell command every interval and notify when its output matches a regex; `list` — show scheduled items; `cancel` — remove one by id.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        action: {
+          type: "string",
+          enum: ["wakeup", "cron", "monitor", "list", "cancel"],
+          description: "What to do",
+        },
+        prompt: {
+          type: "string",
+          description:
+            "For wakeup/cron: the agent prompt to run (via `cc agent -p`) when it fires",
+        },
+        delay: {
+          type: "string",
+          description:
+            "For wakeup: how long from now before it fires (e.g. 30s, 5m, 1h)",
+        },
+        cron: {
+          type: "string",
+          description:
+            'For cron: a 5-field cron expression, e.g. "0 9 * * 1" (09:00 every Monday)',
+        },
+        command: {
+          type: "string",
+          description: "For monitor: the shell command to run each interval",
+        },
+        interval: {
+          type: "string",
+          description:
+            "For monitor: how often to run the command (e.g. 30s, 5m)",
+        },
+        stop_when: {
+          type: "string",
+          description:
+            "For monitor: a regex; when the command output matches, the monitor fires its notification and stops",
+        },
+        notify_title: {
+          type: "string",
+          description: "For monitor: notification title sent when it matches",
+        },
+        max_checks: {
+          type: "number",
+          description:
+            "For monitor: give up after this many checks (optional safety cap)",
+        },
+        label: {
+          type: "string",
+          description: "Optional human label for list/cancel",
+        },
+        id: {
+          type: "string",
+          description: "For cancel: the schedule entry id to remove",
+        },
+      },
+      required: ["action"],
+    },
+    ...TOOL_POLICY_METADATA.schedule,
+    permissions: {
+      level: "standard",
+      scopes: ["schedule:write"],
+    },
+    telemetry: {
+      category: "schedule",
+      tags: ["tool:schedule", "contract:coding-agent", "tier:extension"],
+    },
+  },
 ]);
 
 const CODING_AGENT_MVP_TOOL_NAMES = Object.freeze(

package/src/runtime/coding-agent-policy.cjs

@@ -261,6 +261,34 @@ const TOOL_POLICY_METADATA = Object.freeze({
     approvalFlow: "auto",
     isReadOnly: true,
   },
+  // Sends an outbound notification to the user's own channels/device. No
+  // workspace mutation and no un-gated shell; blocked in plan mode (an
+  // external side effect) but otherwise auto — it targets the user, not a
+  // third party.
+  notify: {
+    riskLevel: RISK_LEVELS.LOW,
+    category: TOOL_CATEGORIES.WRITE,
+    availableInPlanMode: false,
+    planModeBehavior: "blocked",
+    requiresPlanApproval: false,
+    requiresConfirmation: false,
+    approvalFlow: "auto",
+    isReadOnly: false,
+  },
+  // Persists a wakeup/cron/monitor entry for `cc agenda run` to execute later.
+  // Writing the schedule is itself harmless (a JSONL row under the user's
+  // config dir); the eventual `cc agent`/shell run is gated when the agenda
+  // consumer executes it. Blocked in plan mode (schedules future side effects).
+  schedule: {
+    riskLevel: RISK_LEVELS.LOW,
+    category: TOOL_CATEGORIES.WRITE,
+    availableInPlanMode: false,
+    planModeBehavior: "blocked",
+    requiresPlanApproval: false,
+    requiresConfirmation: false,
+    approvalFlow: "auto",
+    isReadOnly: false,
+  },
 });
 
 function normalizeGitCommand(command) {

package/src/assets/web-panel/assets/ChatBubbleRenderer-BFEnA8LN.js

@@ -1 +0,0 @@
-import{I as v,P as u,J as S,U as s,R as n,S as y,K as C,Q as x,V as w,_ as k,b as a}from"./vendor-Bn1JzzAn.js";import{_ as B}from"./index-Ty4w18mR.js";import"./icons-DEmcnxBf.js";const N={__name:"ChatBubbleRenderer",props:{event:{type:Object,required:!0}},setup(c,{expose:d}){d();const t=c,r=a(()=>{const e=t.event.content||{};return e.text||e.body||e.message||e.title||JSON.stringify(e).slice(0,200)}),i=a(()=>{const e=t.event.content||{};return e.from||e.sender||e.senderName||t.event.actor||"(unknown)"}),l=a(()=>{const e=(t.event.actor||"").toLowerCase();return e.includes("self")||e==="me"||e.endsWith("_self")}),o=a(()=>{const e=t.event.source.adapter||"";return e.startsWith("messaging-qq")?"magenta":e==="wechat"?"green":"blue"}),m=a(()=>{if(!t.event.occurredAt)return"";try{const e=new Date(t.event.occurredAt),p=e.getFullYear(),f=String(e.getMonth()+1).padStart(2,"0"),g=String(e.getDate()).padStart(2,"0"),b=String(e.getHours()).padStart(2,"0"),h=String(e.getMinutes()).padStart(2,"0");return`${p}-${f}-${g} ${b}:${h}`}catch{return""}}),_={props:t,messageText:r,actorLabel:i,isMine:l,adapterColor:o,formattedTime:m,computed:a};return Object.defineProperty(_,"__isScriptSetup",{enumerable:!1,value:!0}),_}},T={class:"bubble"},L={class:"meta"},M={class:"actor"},R={class:"time"},V={class:"body"};function q(c,d,t,r,i,l){const o=v("a-tag");return u(),S("div",{class:k(["chat-row",{mine:r.isMine}])},[s("div",T,[s("div",L,[s("span",M,n(r.actorLabel),1),s("span",R,n(r.formattedTime),1)]),s("div",V,n(r.messageText),1),t.event.source.adapter?(u(),y(o,{key:0,class:"src",color:r.adapterColor},{default:C(()=>[x(n(t.event.source.adapter),1)]),_:1},8,["color"])):w("v-if",!0)])],2)}const A=B(N,[["render",q],["__scopeId","data-v-49238629"],["__file","/tmp/cc-web-panel-lLEaak/repo/packages/web-panel/src/components/pdh/renderers/ChatBubbleRenderer.vue"]]);export{A as default};

package/src/assets/web-panel/assets/OrderTableRenderer-CiU4Sy1J.js

@@ -1 +0,0 @@
-import{I as k,P as d,J as u,U as s,R as n,c as i,K as v,Q as _,V as g,b as a}from"./vendor-Bn1JzzAn.js";import{_ as w}from"./index-Ty4w18mR.js";import"./icons-DEmcnxBf.js";const S={__name:"OrderTableRenderer",props:{event:{type:Object,required:!0}},setup(p,{expose:r}){r();const o=p,e=a(()=>o.event.content||{}),l=a(()=>o.event.extra||{}),m=a(()=>l.value.merchant||e.value.merchant||e.value.counterparty||"—"),c=a(()=>e.value.title||e.value.name||e.value.itemName||e.value.text||"—"),y=a(()=>{const t=e.value.amount??e.value.price??e.value.total;return t==null?"—":`${e.value.currency||"¥"} ${typeof t=="number"?t.toFixed(2):t}`}),T=a(()=>l.value.orderNo||e.value.orderNo||e.value.orderId),f=a(()=>e.value.status||e.value.state),b=a(()=>{const t=(f.value||"").toLowerCase();return t.includes("成功")||t.includes("succe")||t.includes("paid")?"green":t.includes("退")||t.includes("refund")?"orange":t.includes("失败")||t.includes("fail")?"red":"default"}),h=a(()=>{if(!o.event.occurredAt)return"";const t=new Date(o.event.occurredAt);return`${t.getFullYear()}-${String(t.getMonth()+1).padStart(2,"0")}-${String(t.getDate()).padStart(2,"0")} ${String(t.getHours()).padStart(2,"0")}:${String(t.getMinutes()).padStart(2,"0")}`}),x={props:o,c:e,e:l,merchantText:m,itemText:c,amountText:y,orderNo:T,statusText:f,statusColor:b,formattedTime:h,computed:a};return Object.defineProperty(x,"__isScriptSetup",{enumerable:!1,value:!0}),x}},N={class:"order-card"},C={class:"head"},O={class:"time"},V={class:"row"},R={class:"val"},B={class:"row"},D={class:"val"},I={class:"row amount-row"},j={class:"val amount"},A={key:0,class:"row"},E={class:"val mono"},F={key:1,class:"row"};function L(p,r,o,e,l,m){const c=k("a-tag");return d(),u("div",N,[s("div",C,[s("span",O,n(e.formattedTime),1),i(c,{color:"gold"},{default:v(()=>[_(n(o.event.source.adapter),1)]),_:1}),i(c,null,{default:v(()=>[_(n(o.event.subtype),1)]),_:1})]),s("div",V,[r[0]||(r[0]=s("span",{class:"key"},"商户",-1)),s("span",R,n(e.merchantText),1)]),s("div",B,[r[1]||(r[1]=s("span",{class:"key"},"商品/项目",-1)),s("span",D,n(e.itemText),1)]),s("div",I,[r[2]||(r[2]=s("span",{class:"key"},"金额",-1)),s("span",j,n(e.amountText),1)]),e.orderNo?(d(),u("div",A,[r[3]||(r[3]=s("span",{class:"key"},"单号",-1)),s("span",E,n(e.orderNo),1)])):g("v-if",!0),e.statusText?(d(),u("div",F,[r[4]||(r[4]=s("span",{class:"key"},"状态",-1)),i(c,{color:e.statusColor},{default:v(()=>[_(n(e.statusText),1)]),_:1},8,["color"])])):g("v-if",!0)])}const J=w(S,[["render",L],["__scopeId","data-v-5ed5524d"],["__file","/tmp/cc-web-panel-lLEaak/repo/packages/web-panel/src/components/pdh/renderers/OrderTableRenderer.vue"]]);export{J as default};