chainlesschain 0.162.115 → 0.162.117

package/src/commands/hub.js

@@ -1114,9 +1114,13 @@ async function cmdCollectQq(options) {
       `qqnt-dec-${process.pid}.db`,
     );
     fs.writeFileSync(tmp, result.decrypted);
-    let events;
+    let parsed;
     try {
-      events = qq.parseEvents(Database, tmp, options.self || "self");
+      // selfUid = the matched account uid → reliable self attribution.
+      parsed = qq.parseEvents(Database, tmp, {
+        selfUid: result.uid,
+        self: options.self || "self",
+      });
     } finally {
       try {
         fs.unlinkSync(tmp);
@@ -1124,7 +1128,24 @@ async function cmdCollectQq(options) {
         /* best-effort wipe */
       }
     }
+    const events = Array.isArray(parsed) ? parsed : parsed.events || [];
+    const persons = Array.isArray(parsed) ? [] : parsed.persons || [];
+    const topics = Array.isArray(parsed) ? [] : parsed.topics || [];
 
+    for (const p of persons) {
+      try {
+        vault.putPerson(p);
+      } catch {
+        /* dup / optional */
+      }
+    }
+    for (const t of topics) {
+      try {
+        if (typeof vault.putTopic === "function") vault.putTopic(t);
+      } catch {
+        /* dup / optional */
+      }
+    }
     let ingested = 0;
     for (const ev of events) {
       try {
@@ -1139,6 +1160,8 @@ async function cmdCollectQq(options) {
       matchedUid: result.uid,
       kdf: result.kdf,
       messages: events.length,
+      persons: persons.length,
+      topics: topics.length,
       ingested,
     };
     if (spinner) spinner.succeed(`collect-qq: ${ingested} QQ messages → vault`);
@@ -1380,6 +1403,121 @@ async function cmdCollectWechat(options) {
   }
 }
 
+// ─── collect-qzone (QQ空间 说说/留言板/相册 via API → vault) ──────────────
+//
+// module 101 — Qzone has no local DB, so this is the cookie+g_tk API path. The
+// Android in-app WebView (or a desktop browser) captures the qzone-domain
+// p_skey cookie; this derives g_tk and pulls the owner's feeds. The cookie is
+// passed via --cookie or --cookie-file (kept out of argv/history when staged).
+async function cmdCollectQzone(options) {
+  const spinner = options.json
+    ? null
+    : ora("collect-qzone (API + ingest)...").start();
+  try {
+    const { createRequire } = await import("module");
+    const require = createRequire(import.meta.url);
+    const fs = require("fs");
+    const qz = options._qzoneCore
+      ? options._qzoneCore
+      : await importPdh(
+          "@chainlesschain/personal-data-hub/forensics/qzone-collect",
+        );
+    let cookie = options.cookie;
+    if (!cookie && options.cookieFile && fs.existsSync(options.cookieFile))
+      cookie = fs.readFileSync(options.cookieFile, "utf8").trim();
+    if (!cookie)
+      throw new Error(
+        'need --cookie "<qzone cookie>" or --cookie-file <path> (must contain uin + p_skey)',
+      );
+    const what = (options.what || "shuoshuo,msgb,album")
+      .split(",")
+      .map((s) => s.trim())
+      .filter(Boolean);
+    const max = Number.isFinite(+options.max) ? +options.max : 1000;
+
+    const result = await qz.collectQzone({
+      uin: options.uin,
+      cookie,
+      what,
+      max,
+      fetchImpl: options._fetch,
+    });
+    if (!result.ok) {
+      const report = { ok: false, reason: result.reason };
+      if (options.json) {
+        jsonAndExit(report);
+        return;
+      }
+      if (spinner) spinner.fail(`collect-qzone: ${result.reason}`);
+      process.exit(2);
+    }
+
+    const hub = await (options._getHub || getHub)();
+    const vault = hub.vault;
+    try {
+      vault.putPerson({
+        type: "person",
+        subtype: "contact",
+        id: qz.SELF_ID,
+        names: ["我(QQ空间)"],
+        source: {
+          adapter: "qzone",
+          adapterVersion: "0.1.0",
+          originalId: qz.SELF_ID,
+          capturedAt: Date.now(),
+          capturedBy: "api",
+        },
+        ingestedAt: Date.now(),
+      });
+    } catch {
+      /* dup */
+    }
+    for (const p of result.persons) {
+      try {
+        vault.putPerson(p);
+      } catch {
+        /* dup */
+      }
+    }
+    let ingested = 0;
+    for (const ev of result.events) {
+      try {
+        vault.putEvent(ev);
+        ingested++;
+      } catch {
+        /* dup */
+      }
+    }
+
+    const report = {
+      ok: true,
+      uin: result.uin,
+      counts: result.counts,
+      events: result.events.length,
+      persons: result.persons.length,
+      ingested,
+    };
+    if (spinner)
+      spinner.succeed(
+        `collect-qzone: ${ingested} events → vault (${Object.entries(
+          result.counts,
+        )
+          .map(([k, v]) => k + ":" + v)
+          .join(" ")})`,
+      );
+    if (options.json) {
+      jsonAndExit(report);
+      return;
+    }
+    logger.log(chalk.green("✓ Qzone collect succeeded"));
+    logger.log(`  counts:    ${JSON.stringify(result.counts)}`);
+    logger.log(`  ingested:  ${ingested}`);
+    process.exit(0);
+  } catch (err) {
+    fail(spinner, err, options.json);
+  }
+}
+
 // ─── Phase 10.3 — cc hub aichat <verb> wizard subcommand surface ─────
 //
 // Mirrors the WS topics (personal-data-hub.aichat-*) so scripts and the
@@ -3188,6 +3326,29 @@ export function registerHubCommand(program) {
     .option("--json", "Output JSON")
     .action(cmdCollectWechat);
 
+  hub
+    .command("collect-qzone")
+    .description(
+      "QQ空间 (Qzone): collect 说说/留言板/相册 via the Qzone CGI API. No local DB — needs the qzone-domain p_skey cookie (from the in-app WebView or a browser login to user.qzone.qq.com; base .qq.com skey is rejected). Derives g_tk from p_skey and ingests as post/message/media events.",
+    )
+    .option(
+      "--cookie <cookie>",
+      "Qzone cookie string (must contain uin + p_skey)",
+    )
+    .option(
+      "--cookie-file <path>",
+      "File holding the cookie (preferred — keeps it out of argv)",
+    )
+    .option("--uin <uin>", "Account uin (else parsed from cookie)")
+    .option(
+      "--what <list>",
+      "Comma list: shuoshuo,msgb,album (default all)",
+      "shuoshuo,msgb,album",
+    )
+    .option("--max <n>", "Max items per source", "1000")
+    .option("--json", "Output JSON")
+    .action(cmdCollectQzone);
+
   hub
     .command("event-detail <eventId>")
     .description(

package/src/harness/mcp-client.js

@@ -347,6 +347,23 @@ export class MCPClient extends EventEmitter {
       };
     } catch (err) {
       entry.state = ServerState.ERROR;
+      // A stdio child spawned above but failed to initialize (handshake
+      // timeout / broken pipe / non-MCP command) would otherwise leak: we
+      // delete the entry from `this.servers` below, so disconnect() can never
+      // reach it, and an alive-but-unresponsive process fires neither `close`
+      // nor `error` — it would run orphaned with its stdio listeners bound for
+      // the lifetime of the CLI. Tear it down on the way out (best-effort;
+      // never mask the original connect error).
+      if (entry.process) {
+        try {
+          entry.process.stdout?.removeAllListeners();
+          entry.process.stderr?.removeAllListeners();
+          entry.process.removeAllListeners();
+          entry.process.kill();
+        } catch {
+          // teardown is best-effort — the connect error is what matters
+        }
+      }
       this.servers.delete(name);
       throw err;
     }

package/src/lib/checkpoint-store.js

@@ -91,6 +91,36 @@ function tempIndexPath(dir) {
   return path.join(dir, `cc-checkpoint-index-${process.pid}-${Date.now()}`);
 }
 
+/**
+ * rmSync that never throws. Used for best-effort teardown (temp index files,
+ * created-since files) so a transient unlink failure — e.g. a Windows file
+ * lock (EBUSY/EPERM) on the temp index — can't mask the operation's real
+ * result. Without this, a `finally { rmSync(tmpIndex) }` could turn a
+ * *successful* checkpoint into a thrown error, or replace the original git
+ * error with the cleanup error.
+ */
+function rmQuiet(target) {
+  try {
+    rmSync(target, { force: true });
+  } catch {
+    /* best-effort cleanup — the operation's real result is what matters */
+  }
+}
+
+/**
+ * True if `abs` is the repo root or lives inside it (containment guard).
+ * Both sides go through path.resolve so the comparison is robust to separator
+ * style — `repoRoot()` comes from `git rev-parse --show-toplevel` with forward
+ * slashes, while path.resolve yields native (backslash) paths on Windows.
+ */
+export function withinRoot(root, abs) {
+  const r = path.resolve(root);
+  const a = path.resolve(abs);
+  if (a === r) return true;
+  const prefix = r.endsWith(path.sep) ? r : r + path.sep;
+  return a.startsWith(prefix);
+}
+
 /**
  * Snapshot the current working tree to a git tree object WITHOUT creating a
  * commit and WITHOUT touching the real index. Returns the tree sha.
@@ -107,7 +137,7 @@ function snapshotTree(root, dir) {
     git(["add", "-A"], { cwd: root, env });
     return git(["write-tree"], { cwd: root, env });
   } finally {
-    rmSync(tmpIndex, { force: true });
+    rmQuiet(tmpIndex);
   }
 }
 
@@ -228,7 +258,7 @@ export function createCheckpoint(cwd = process.cwd(), opts = {}) {
 
     return { id, ref, commit, tree, parent, label, session, createdAt, files };
   } finally {
-    rmSync(tmpIndex, { force: true });
+    rmQuiet(tmpIndex);
   }
 }
 
@@ -380,12 +410,19 @@ export function rewindTo(cwd = process.cwd(), idOrRef, opts = {}) {
     git(["read-tree", targetTree], { cwd: root, env });
     git(["checkout-index", "-a", "-f"], { cwd: root, env });
   } finally {
-    rmSync(tmpIndex, { force: true });
+    rmQuiet(tmpIndex);
   }
 
-  // Remove files the target snapshot does not contain (created since).
+  // Remove files the target snapshot does not contain (created since). These
+  // paths come from git's tree diff (repo-relative, git rejects `..` in tree
+  // entries), but this is a force-delete over the user's working tree — guard
+  // each resolved path against the repo root before unlinking, as
+  // defense-in-depth, and keep it best-effort so one locked file can't abort
+  // the whole rewind.
   for (const rel of added) {
-    rmSync(path.resolve(root, rel), { force: true });
+    const abs = path.resolve(root, rel);
+    if (!withinRoot(root, abs)) continue; // never delete outside the repo
+    rmQuiet(abs);
   }
 
   return {

package/src/lib/cost-budget.js

@@ -62,14 +62,27 @@ export class CostBudget {
    * @returns {object} the estimateCost() result for this record
    */
   add({ provider, model, usage } = {}) {
+    // Prompt-cache tokens are billed too — cache CREATION at ~125% of the input
+    // rate (Anthropic), cache READ at 10–50%. The usage events carry
+    // cache_read_input_tokens / cache_creation_input_tokens, and `cc cost`
+    // already prices them; the hard --max-budget-usd cap must count them as well
+    // or it undercounts real spend on a cached Anthropic run and stops too late.
+    const cacheReadTokens = usage?.cache_read_input_tokens || 0;
+    const cacheCreationTokens = usage?.cache_creation_input_tokens || 0;
     const est = estimateCost({
       provider,
       model,
       inputTokens: usage?.input_tokens || 0,
       outputTokens: usage?.output_tokens || 0,
+      cacheReadTokens,
+      cacheCreationTokens,
       table: this.table,
     });
-    const tokens = (usage?.input_tokens || 0) + (usage?.output_tokens || 0);
+    const tokens =
+      (usage?.input_tokens || 0) +
+      (usage?.output_tokens || 0) +
+      cacheReadTokens +
+      cacheCreationTokens;
     if (est.free) {
       this.sawFree = true;
     } else if (est.matched) {

package/src/lib/cross-chain-mtc.js

@@ -749,6 +749,16 @@ export function verifyMultisigProvenance(envelope, policy) {
   if (prov.signers.length !== prov.partial_sigs.length) {
     return { ok: false, code: "SIGNERS_SIGS_LENGTH_MISMATCH" };
   }
+  // A group of N members cannot produce more than N distinct signers; a
+  // provenance that lists more is self-inconsistent (and, without a
+  // policy.members roster below, would otherwise pass).
+  if (prov.signers.length > prov.member_count_n) {
+    return {
+      ok: false,
+      code: "TOO_MANY_SIGNERS",
+      detail: `${prov.signers.length} > ${prov.member_count_n}`,
+    };
+  }
   const requiredM =
     policy && Number.isInteger(policy.m) ? policy.m : prov.threshold_m;
   if (prov.partial_sigs.length < requiredM) {
@@ -764,6 +774,13 @@ export function verifyMultisigProvenance(envelope, policy) {
       return { ok: false, code: "SIGNERS_NOT_SORTED" };
     }
   }
+  // Signers must be distinct: duplicates (e.g. ["a","a","a"]) would otherwise
+  // let a single member meet an M-of-N threshold by repeating themselves.
+  for (let i = 1; i < sorted.length; i++) {
+    if (sorted[i] === sorted[i - 1]) {
+      return { ok: false, code: "DUPLICATE_SIGNER", detail: sorted[i] };
+    }
+  }
   const allowed =
     policy && Array.isArray(policy.members)
       ? new Set(policy.members.map((m) => m.did))

package/src/lib/dlp-engine.js

@@ -193,7 +193,9 @@ export function listIncidents(filter = {}) {
   if (filter.severity) {
     incidents = incidents.filter((i) => i.severity === filter.severity);
   }
-  if (filter.resolved === false) {
+  if (filter.resolved === true) {
+    incidents = incidents.filter((i) => !!i.resolvedAt);
+  } else if (filter.resolved === false) {
     incidents = incidents.filter((i) => !i.resolvedAt);
   }
   const limit = filter.limit || 50;

package/src/lib/hook-runner.cjs

@@ -31,16 +31,30 @@ const HOOK_DECISIONS = Object.freeze({
   CONTINUE: "continue",
 });
 
+/** JSON.parse that returns undefined (not throws) on failure. */
+function tryJson(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return undefined;
+  }
+}
+
 /** Parse a hook's stdout JSON into a normalized decision, or null if not JSON. */
 function tryParseDecision(stdout) {
   const text = String(stdout || "").trim();
   if (!text || text[0] !== "{") return null;
-  let obj;
-  try {
-    obj = JSON.parse(text);
-  } catch {
-    return null;
+  let obj = tryJson(text);
+  if (obj === undefined) {
+    // A hook that emits its decision as a JSON line followed by diagnostics
+    // (`{"decision":"block"}\n…log lines…`) would fail a whole-text parse, so
+    // the documented JSON-to-block pattern would be silently dropped and the
+    // tool would proceed. Recover the decision from the first line. (Pure
+    // pretty-printed JSON still parses via the whole-text attempt above.)
+    const firstLine = text.split("\n", 1)[0].trim();
+    if (firstLine && firstLine[0] === "{") obj = tryJson(firstLine);
   }
+  if (obj === undefined || obj === null || typeof obj !== "object") return null;
   // PreToolUse-specific permission decision
   const hso = obj.hookSpecificOutput;
   if (hso && hso.permissionDecision) {
@@ -148,7 +162,22 @@ function runCommandHook(command, input = {}, opts = {}) {
   if (exitCode === 0) {
     const parsed = tryParseDecision(stdout);
     if (parsed) return { ...parsed, exitCode, stdout, stderr };
-    return { decision: HOOK_DECISIONS.CONTINUE, reason: null, exitCode, stdout, stderr };
+    // stdout that *looks* like a decision (`{`-leading) but parses as neither
+    // whole-text nor first-line JSON is most likely a corrupt/truncated
+    // decision — don't swallow it silently (a block hook could be neutered).
+    // The exit code (0) still governs the flow (continue), but flag it so the
+    // caller/logs can surface the misconfiguration.
+    const looksLikeDecision = stdout.trim()[0] === "{";
+    return {
+      decision: HOOK_DECISIONS.CONTINUE,
+      reason: looksLikeDecision
+        ? "hook stdout looked like a decision but did not parse as JSON"
+        : null,
+      exitCode,
+      stdout,
+      stderr,
+      ...(looksLikeDecision ? { malformedDecision: true } : {}),
+    };
   }
   // Other non-zero → non-blocking error.
   return {

package/src/lib/loop.js

@@ -108,15 +108,22 @@ export function makeSleep(signal) {
       // process alive between rounds. Under a TTY the active stdin would mask
       // an unref'd timer, but headless (piped stdin / CI / cron) the loop would
       // exit after the first round. SIGINT aborts the wait via the signal.
-      const t = setTimeout(resolve, ms);
-      signal?.addEventListener(
-        "abort",
-        () => {
-          clearTimeout(t);
-          resolve();
-        },
-        { once: true },
-      );
+      let t;
+      const onAbort = () => {
+        clearTimeout(t);
+        resolve();
+      };
+      t = setTimeout(() => {
+        // Normal completion: drop the abort listener so it can't accumulate on
+        // a shared signal across rounds. A long `cc loop` reuses one
+        // AbortController for the whole run, and `{once:true}` only removes the
+        // listener if it FIRES — a sleep that completes normally never aborts,
+        // so without this each round would leak a dangling listener (N rounds →
+        // N retained closures + a MaxListenersExceededWarning past 10).
+        signal?.removeEventListener("abort", onAbort);
+        resolve();
+      }, ms);
+      signal?.addEventListener("abort", onAbort, { once: true });
     });
 }
 

package/src/lib/permission-rules.cjs

@@ -206,10 +206,14 @@ function matchCommand(pattern, command) {
 function matchUrl(pattern, url) {
   const u = String(url || "");
   if (pattern.startsWith("domain:")) {
-    const host = pattern.slice("domain:".length).trim();
+    // Domains are case-insensitive (and `new URL().host` already lowercases the
+    // host), so lowercase the pattern too — otherwise a rule with any uppercase
+    // (`domain:Example.com`) silently never matches, turning a deny rule into a
+    // bypass and an allow rule into a no-op.
+    const host = pattern.slice("domain:".length).trim().toLowerCase();
     let actualHost = "";
     try {
-      actualHost = new URL(u).host;
+      actualHost = new URL(u).host.toLowerCase();
     } catch {
       return false;
     }

package/src/lib/skill-loader.js

@@ -120,6 +120,15 @@ export function parseSkillMd(content) {
         .slice(2)
         .trim()
         .replace(/^['"]|['"]$/g, "");
+      // Lazily start a block array on the first item under an empty-value key
+      // (`tools:\n  - Read\n  - Write`). Without this, currentArray was never
+      // assigned anywhere, so block-style YAML lists were silently dropped —
+      // e.g. an `allowed-tools:` list would vanish and its restriction be lost.
+      // Only create when the key carried no inline value (data[key] still
+      // undefined) so a scalar isn't clobbered by a stray dash.
+      if (!currentArray && currentKey && data[currentKey] === undefined) {
+        currentArray = data[currentKey] = [];
+      }
       if (currentArray) currentArray.push(value);
       continue;
     }

package/src/lib/web-fetch.js

@@ -12,21 +12,50 @@ import { URL } from "url";
 const DEFAULT_MAX_BYTES = 2_000_000;
 const DEFAULT_TIMEOUT_MS = 15_000;
 
-// RFC 1918 + loopback + link-local. Blocked by default unless config.allowPrivateHosts.
+// RFC 1918 + loopback + link-local (IPv4 and IPv6). Blocked by default unless
+// config.allowPrivateHosts. Decimal/integer IPv4 forms (http://2130706433,
+// http://0) are normalized to dotted-decimal by `new URL()` before they reach
+// here, so the IPv4 patterns catch them too.
 const PRIVATE_HOST_PATTERNS = [
   /^127\./,
   /^10\./,
   /^192\.168\./,
   /^172\.(1[6-9]|2\d|3[01])\./,
-  /^169\.254\./,
+  /^169\.254\./, // link-local incl. cloud metadata 169.254.169.254
   /^0\.0\.0\.0$/,
-  /^::1$/,
+  /^0$/, // bare 0 → 0.0.0.0
+  /^::1$/, // IPv6 loopback
+  /^::$/, // IPv6 unspecified (== 0.0.0.0)
+  /^f[cd][0-9a-f]{2}:/, // fc00::/7 unique-local (ULA)
+  /^fe[89ab][0-9a-f]:/, // fe80::/10 link-local
   /^localhost$/i,
 ];
 
+// Decode the IPv4 embedded in an IPv4-mapped IPv6 address back to dotted form,
+// or null if `h` is not such an address. `new URL()` normalizes the embedded
+// IPv4 to hex (::ffff:127.0.0.1 → ::ffff:7f00:1), so without decoding, a fetch
+// to [::ffff:127.0.0.1] would bypass the IPv4 loopback/private rules.
+function mappedIPv4(h) {
+  const m = /^::ffff:(.+)$/.exec(h);
+  if (!m) return null;
+  const tail = m[1];
+  if (/^\d{1,3}(\.\d{1,3}){3}$/.test(tail)) return tail; // already dotted
+  const hx = /^([0-9a-f]{1,4}):([0-9a-f]{1,4})$/.exec(tail);
+  if (!hx) return null;
+  const a = parseInt(hx[1], 16);
+  const b = parseInt(hx[2], 16);
+  return [(a >> 8) & 255, a & 255, (b >> 8) & 255, b & 255].join(".");
+}
+
 export function isPrivateHost(host) {
   if (!host) return true;
-  return PRIVATE_HOST_PATTERNS.some((re) => re.test(host));
+  let h = String(host).toLowerCase();
+  // `new URL().hostname` returns IPv6 hosts bracketed ("[::1]") — strip so the
+  // IPv6 patterns (and the previously-dead ::1 rule) actually match.
+  if (h.startsWith("[") && h.endsWith("]")) h = h.slice(1, -1);
+  const v4 = mappedIPv4(h);
+  if (v4) h = v4; // re-check the embedded IPv4 against the IPv4 rules
+  return PRIVATE_HOST_PATTERNS.some((re) => re.test(h));
 }
 
 export function checkAllowed(urlStr, config = {}) {

package/src/repl/agent-repl.js

@@ -1562,6 +1562,18 @@ export async function startAgentRepl(options = {}) {
         model = arg;
         _curModel = model; // keep the status-line readout in sync
         logger.info(`Model: ${chalk.cyan(model)}`);
+        // Claude-Code 2.1.183 parity: warn when the newly-selected model is a
+        // provider-retired/deprecated snapshot. Headless paths already warn via
+        // maybeWarnDeprecatedModel; the interactive /model switch did not, so a
+        // user could silently switch to a retired id and only learn of it when
+        // the next turn fails with an opaque "model not found".
+        try {
+          const { maybeWarnDeprecatedModel } =
+            await import("../lib/model-deprecation.js");
+          maybeWarnDeprecatedModel({ model });
+        } catch {
+          // deprecation notice is best-effort
+        }
       } else {
         logger.info(`Current model: ${chalk.cyan(model)}`);
       }

package/src/runtime/headless-runner.js

@@ -768,6 +768,20 @@ export async function runAgentHeadless(options = {}, deps = {}) {
     // chatFn passthrough lets tests drive the loop deterministically.
     chatFn: deps.chatFn || options.chatFn || undefined,
     signal: options.signal || undefined,
+    // Stream-stall hint (Claude-Code 2.1.185): when the connection is alive but
+    // the API has gone silent mid-response, a headless run would otherwise look
+    // frozen with no feedback. The REPL already surfaces this; mirror it here to
+    // stderr — out-of-band for every output format (text answer / json envelope
+    // / stream-json NDJSON all go to stdout) so machine consumers are unaffected
+    // while a human watching a long `cc agent -p` run learns we're still waiting
+    // and, when a hard inactivity timeout is set, when it will auto-retry. Plain
+    // text (no chalk) since headless stderr is frequently piped/non-TTY.
+    onStall: (ms, timeoutMs) => {
+      const silent = Math.round(ms / 1000);
+      const retryIn = timeoutMs > ms ? Math.round((timeoutMs - ms) / 1000) : 0;
+      const suffix = retryIn > 0 ? ` · will retry in ${retryIn}s` : "";
+      writeErr(`  ⏳ waiting for API response (silent ${silent}s)${suffix}…\n`);
+    },
   };
 
   // Goal binding (cc goal, Phase 1). `--goal <id>` binds explicitly; `--goal`

package/src/assets/web-panel/assets/ChatBubbleRenderer-Cr-ifTsG.js

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