chainlesschain 0.162.32 → 0.162.33

package/src/lib/goal-assess.js

@@ -0,0 +1,228 @@
+/**
+ * goal-assess — run-end LLM self-assessment of goal progress (cc goal Phase 2).
+ *
+ * After an agent run bound to a goal (--goal-assess), an LLM is asked to judge,
+ * from the run transcript, whether the goal advanced — and to propose key-result
+ * updates, a one-line progress note, and any concerns. The proposal is then
+ * persisted through goal-store (progress / key results / agent note / drift).
+ *
+ * This is OPT-IN because it spends extra tokens (one bonus completion per run).
+ * The LLM call is injected as `chat(promptString) => Promise<string>` so the
+ * orchestration is deterministically unit-testable without a provider.
+ *
+ * Parsing is deliberately tolerant: models wrap JSON in prose / code fences, so
+ * we extract the first balanced `{...}` block and validate the fields we use.
+ */
+
+import {
+  recordProgress,
+  setKeyResult,
+  addDriftFlags,
+  getGoal,
+} from "./goal-store.js";
+
+/** Bound the transcript we feed the judge so the assessment stays cheap. */
+const MAX_FINAL_TEXT = 2000;
+const MAX_TOOLS = 40;
+
+/**
+ * Build the assessment prompt. Asks for a strict JSON object describing whether
+ * the goal advanced + proposed updates.
+ * @param {object} goal
+ * @param {object} transcript { prompt, finalText, toolCalls:[{tool,args}] }
+ */
+export function buildAssessPrompt(goal, transcript = {}) {
+  const krLines = (goal.keyResults || [])
+    .map(
+      (k) =>
+        `  - id=${k.id} | "${k.text}"` +
+        (k.target != null ? ` | ${k.current ?? 0}/${k.target}` : "") +
+        (k.done ? " | DONE" : ""),
+    )
+    .join("\n");
+
+  const tools = (transcript.toolCalls || [])
+    .slice(0, MAX_TOOLS)
+    .map((t) => t.tool)
+    .join(", ");
+
+  const finalText = String(transcript.finalText || "").slice(0, MAX_FINAL_TEXT);
+
+  return [
+    "You are assessing whether a single agent run advanced a long-running goal.",
+    "",
+    `GOAL: ${goal.objective}`,
+    `CURRENT PROGRESS: ${goal.progress ?? 0}%`,
+    goal.keyResults?.length
+      ? `KEY RESULTS:\n${krLines}`
+      : "KEY RESULTS: (none)",
+    "",
+    `RUN TASK: ${String(transcript.prompt || "").slice(0, 500)}`,
+    tools ? `TOOLS USED: ${tools}` : "TOOLS USED: (none)",
+    `RUN RESULT:\n${finalText || "(no final text)"}`,
+    "",
+    "Reply with ONLY a JSON object (no prose, no code fence) of this shape:",
+    "{",
+    '  "advanced": true|false,            // did this run move the goal forward?',
+    '  "progress": <0-100 or null>,        // your estimate of new overall progress, or null to leave unchanged',
+    '  "keyResults": [                     // updates for specific key results (omit if none)',
+    '    {"id": "<kr-id>", "current": <number or null>, "done": true|false}',
+    "  ],",
+    '  "note": "<one short sentence summarizing what changed>",',
+    '  "concerns": ["<short concern>", ...]   // anything blocking/at-risk (omit if none)',
+    "}",
+  ].join("\n");
+}
+
+/**
+ * Tolerantly parse the judge's reply into a normalized assessment, or null.
+ * @param {string} text
+ * @returns {{advanced:boolean, progress:number|null, keyResults:object[], note:string, concerns:string[]}|null}
+ */
+export function parseAssessment(text) {
+  if (!text || typeof text !== "string") return null;
+  const json = extractFirstJsonObject(text);
+  if (!json) return null;
+  let obj;
+  try {
+    obj = JSON.parse(json);
+  } catch {
+    return null;
+  }
+  if (!obj || typeof obj !== "object") return null;
+
+  const progress =
+    obj.progress == null || obj.progress === "" ? null : clampPct(obj.progress);
+
+  const keyResults = Array.isArray(obj.keyResults)
+    ? obj.keyResults
+        .filter((k) => k && k.id)
+        .map((k) => ({
+          id: String(k.id),
+          current:
+            k.current == null || k.current === "" ? null : Number(k.current),
+          done: k.done === true,
+        }))
+    : [];
+
+  const concerns = Array.isArray(obj.concerns)
+    ? obj.concerns.map((c) => String(c)).filter(Boolean)
+    : [];
+
+  return {
+    advanced: obj.advanced === true,
+    progress,
+    keyResults,
+    note: obj.note ? String(obj.note) : "",
+    concerns,
+  };
+}
+
+function clampPct(v) {
+  const n = Math.round(Number(v));
+  if (!Number.isFinite(n)) return null;
+  return Math.max(0, Math.min(100, n));
+}
+
+/** Extract the first balanced top-level {...} block from text (fence-tolerant). */
+function extractFirstJsonObject(text) {
+  const start = text.indexOf("{");
+  if (start < 0) return null;
+  let depth = 0;
+  let inStr = false;
+  let esc = false;
+  for (let i = start; i < text.length; i++) {
+    const ch = text[i];
+    if (inStr) {
+      if (esc) esc = false;
+      else if (ch === "\\") esc = true;
+      else if (ch === '"') inStr = false;
+      continue;
+    }
+    if (ch === '"') inStr = true;
+    else if (ch === "{") depth++;
+    else if (ch === "}") {
+      depth--;
+      if (depth === 0) return text.slice(start, i + 1);
+    }
+  }
+  return null;
+}
+
+/**
+ * Persist a parsed assessment to the goal via goal-store. Each sub-update is
+ * isolated (a bad key-result id can't void the progress note). Returns the
+ * final goal state.
+ * @param {string} goalId
+ * @param {object} a  output of parseAssessment
+ * @param {object} [opts] { root }
+ */
+export function applyAssessment(goalId, a, opts = {}) {
+  if (!a) return getGoal(goalId, opts);
+
+  // Key-result updates first (they may drive derived progress).
+  for (const kr of a.keyResults || []) {
+    try {
+      setKeyResult(goalId, kr.id, { current: kr.current, done: kr.done }, opts);
+    } catch {
+      /* unknown / stale key-result id — skip, don't void the rest */
+    }
+  }
+
+  // Explicit progress and/or the agent note.
+  if (a.progress != null || a.note) {
+    try {
+      recordProgress(
+        goalId,
+        { pct: a.progress, note: a.note, by: "agent" },
+        opts,
+      );
+    } catch {
+      /* best-effort */
+    }
+  }
+
+  // Drift: a no-advance run, plus any explicit concerns.
+  const flags = [];
+  if (!a.advanced) {
+    flags.push({ kind: "no-progress", detail: "run did not advance the goal" });
+  }
+  for (const c of a.concerns || []) flags.push({ kind: "concern", detail: c });
+  if (flags.length) {
+    try {
+      addDriftFlags(goalId, flags, opts);
+    } catch {
+      /* best-effort */
+    }
+  }
+
+  return getGoal(goalId, opts);
+}
+
+/**
+ * Full orchestration: prompt → chat → parse → apply. Returns
+ * `{ assessment, goal }` (assessment is null when the judge gave no usable JSON).
+ * @param {object} params { goal, transcript, chat, opts }
+ *        chat: (promptString) => Promise<string>
+ */
+export async function assessGoalProgress({
+  goal,
+  transcript,
+  chat,
+  opts = {},
+}) {
+  if (!goal || typeof chat !== "function") {
+    return { assessment: null, goal: goal || null };
+  }
+  const prompt = buildAssessPrompt(goal, transcript);
+  let reply;
+  try {
+    reply = await chat(prompt);
+  } catch {
+    return { assessment: null, goal };
+  }
+  const assessment = parseAssessment(reply);
+  if (!assessment) return { assessment: null, goal };
+  const updated = applyAssessment(goal.id, assessment, opts);
+  return { assessment, goal: updated };
+}

package/src/lib/goal-store.js

@@ -270,6 +270,39 @@ export function setStatus(id, status, opts = {}) {
   );
 }
 
+/**
+ * Append drift flags to a goal's `drift.flags` list. Each flag is normalized to
+ * `{ at, kind, detail }`. Used by the run-end assessment (cc goal Phase 2) to
+ * record "no progress this run" / concern signals. Capped at 20 (newest kept).
+ * @param {string} id
+ * @param {Array<string|object>} flags
+ */
+export function addDriftFlags(id, flags, opts = {}) {
+  const list = (Array.isArray(flags) ? flags : [flags]).filter(Boolean);
+  if (list.length === 0) return getGoal(id, opts);
+  return mutate(
+    id,
+    (g) => {
+      for (const f of list) {
+        const flag =
+          typeof f === "string"
+            ? { at: nowIso(), kind: "concern", detail: f }
+            : {
+                at: nowIso(),
+                kind: f.kind || "concern",
+                detail: f.detail || "",
+              };
+        g.drift.flags.push(flag);
+      }
+      // Keep only the most recent 20 to bound the file size.
+      if (g.drift.flags.length > 20) {
+        g.drift.flags = g.drift.flags.slice(-20);
+      }
+    },
+    opts,
+  );
+}
+
 /** Delete a goal. Returns true if it existed. */
 export function deleteGoal(id, opts = {}) {
   const root = opts.root || defaultRoot();

package/src/runtime/agent-core.js

@@ -2198,12 +2198,34 @@ export async function* agentLoop(messages, options) {
           );
           if (stats.saved > 0 && compacted.length < messages.length) {
             messages.splice(0, messages.length, ...compacted);
+            // Persist the compaction so a later --resume rebuilds from the
+            // shortened history. An explicit `onCompaction` hook (if a caller
+            // provides one) takes precedence; otherwise self-persist a `compact`
+            // event — but only when the session is already being persisted to
+            // disk (the JSONL file exists), so a one-shot `cc agent -p` (which
+            // never creates a session file) writes nothing. Opt out with
+            // `persistCompaction: false`. Best-effort throughout.
             if (typeof options.onCompaction === "function") {
               try {
                 options.onCompaction(stats, compacted);
               } catch {
                 // persistence is best-effort
               }
+            } else if (
+              options.sessionId &&
+              options.persistCompaction !== false
+            ) {
+              try {
+                const store = await import("../harness/jsonl-session-store.js");
+                if (store.sessionExists(options.sessionId)) {
+                  store.appendCompactEvent(options.sessionId, {
+                    ...stats,
+                    messages: compacted,
+                  });
+                }
+              } catch {
+                // self-persist is best-effort
+              }
             }
             yield { type: "compaction", stats, runId };
           }

package/src/runtime/headless-runner.js

@@ -26,12 +26,14 @@ import {
   agentLoop as coreAgentLoop,
   formatToolArgs,
 } from "./agent-core.js";
+import { loadMcpConfig } from "./mcp-config.js";
 import { IterationBudget } from "../lib/iteration-budget.js";
 import {
   startSession as jsonlStartSession,
   appendUserMessage as jsonlAppendUserMessage,
   appendAssistantMessage as jsonlAppendAssistantMessage,
   appendTokenUsage as jsonlAppendTokenUsage,
+  appendCompactEvent as jsonlAppendCompactEvent,
   rebuildMessages as jsonlRebuildMessages,
   sessionExists as jsonlSessionExists,
   getLastSessionId as jsonlGetLastSessionId,
@@ -245,6 +247,7 @@ export async function runAgentHeadless(options = {}, deps = {}) {
     appendAssistantMessage:
       deps.appendAssistantMessage || jsonlAppendAssistantMessage,
     appendTokenUsage: deps.appendTokenUsage || jsonlAppendTokenUsage,
+    appendCompactEvent: deps.appendCompactEvent || jsonlAppendCompactEvent,
     getLastSessionId: deps.getLastSessionId || jsonlGetLastSessionId,
   };
   const isStream = outputFormat === "stream-json";
@@ -367,6 +370,26 @@ export async function runAgentHeadless(options = {}, deps = {}) {
     }
   }
 
+  // --mcp-config: connect ad-hoc MCP servers for this run and expose their
+  // tools to the LLM (Claude-Code parity). Connection is best-effort — a server
+  // that fails to connect is logged to stderr and contributes no tools; a
+  // missing/empty config file fails fast (the user explicitly asked for MCP).
+  let mcp = null;
+  if (options.mcpConfig) {
+    const doLoadMcp = deps.loadMcpConfig || loadMcpConfig;
+    try {
+      mcp = await doLoadMcp(options.mcpConfig, { writeErr });
+      if (isText) {
+        for (const c of mcp.connected) {
+          writeErr(`  mcp: ${c.server} (${c.tools} tools)\n`);
+        }
+      }
+    } catch (err) {
+      writeErr(`Error: ${err.message}\n`);
+      return { exitCode: 1, result: err.message, isError: true };
+    }
+  }
+
   const loopOptions = {
     model,
     provider,
@@ -382,11 +405,48 @@ export async function runAgentHeadless(options = {}, deps = {}) {
     enabledToolNames,
     disabledTools,
     iterationBudget: budget,
+    // --mcp-config wiring: tool defs for the LLM + dispatch map + live client.
+    mcpClient: mcp?.mcpClient || null,
+    extraToolDefinitions: mcp?.extraToolDefinitions || undefined,
+    externalToolExecutors: mcp?.externalToolExecutors || undefined,
+    externalToolDescriptors: mcp?.externalToolDescriptors || undefined,
     // chatFn passthrough lets tests drive the loop deterministically.
     chatFn: deps.chatFn || options.chatFn || undefined,
     signal: options.signal || undefined,
   };
 
+  // Goal binding (cc goal, Phase 1). `--goal <id>` binds explicitly; `--goal`
+  // with no value (options.goal === true) auto-resolves from active/session.
+  // When omitted, headless stays goal-free (no behavior change). Best-effort:
+  // a failure here must never fail the run.
+  let boundGoalId = null;
+  if (options.goal !== undefined && options.goal !== false) {
+    try {
+      const explicitId = typeof options.goal === "string" ? options.goal : null;
+      const { resolveActiveGoal, linkSession } =
+        await import("../lib/goal-store.js");
+      const goal = (deps.resolveActiveGoal || resolveActiveGoal)({
+        explicitId,
+        sessionId,
+      });
+      if (goal) {
+        const { goalPrepareCall } = await import("../lib/goal-context.js");
+        loopOptions.prepareCall = goalPrepareCall(goal);
+        boundGoalId = goal.id;
+        // Link the session so a later `--continue`/`--resume` keeps this goal.
+        if (explicitId && persist !== false) {
+          try {
+            linkSession(goal.id, sessionId);
+          } catch {
+            /* linking is optional polish — never fatal */
+          }
+        }
+      }
+    } catch {
+      /* goal binding is best-effort — proceed without it */
+    }
+  }
+
   const startedAt = deps.now ? deps.now() : Date.now();
   const toolCalls = [];
   const usage = { input_tokens: 0, output_tokens: 0 };
@@ -424,6 +484,7 @@ export async function runAgentHeadless(options = {}, deps = {}) {
     resumed_from: resumeId,
     history_messages: history.length,
     additional_directories: additionalDirectories,
+    goal_id: boundGoalId,
   });
 
   try {
@@ -522,6 +583,17 @@ export async function runAgentHeadless(options = {}, deps = {}) {
       writeErr(`Error: ${message}\n`);
     }
     return { exitCode: 1, result: message, isError: true };
+  } finally {
+    // Tear down ad-hoc MCP servers (--mcp-config) before returning, whether the
+    // loop completed or threw. Best-effort: a failed disconnect never masks the
+    // run's own outcome.
+    if (mcp?.mcpClient) {
+      try {
+        await mcp.mcpClient.disconnectAll();
+      } catch {
+        // ignore — disconnect is best-effort
+      }
+    }
   }
 
   // coreAgentLoop emits run-ended reason "budget-exhausted" when the iteration
@@ -543,6 +615,56 @@ export async function runAgentHeadless(options = {}, deps = {}) {
     }
   }
 
+  // Run-end goal self-assessment (cc goal Phase 2, opt-in via --goal-assess).
+  // Spends one extra completion to judge whether the run advanced the bound
+  // goal, then persists progress / key-result / drift updates. Best-effort: it
+  // must never change the run's own outcome.
+  if (options.goalAssess && boundGoalId && !isError) {
+    try {
+      const { getGoal } = await import("../lib/goal-store.js");
+      const goal = (deps.getGoal || getGoal)(boundGoalId);
+      if (goal) {
+        const { assessGoalProgress } = await import("../lib/goal-assess.js");
+        const doAssess = deps.assessGoalProgress || assessGoalProgress;
+        const assessChat =
+          deps.assessChat ||
+          (async (assessPrompt) => {
+            const { chatWithTools } = await import("./agent-core.js");
+            const r = await chatWithTools(
+              [{ role: "user", content: assessPrompt }],
+              { model, provider, baseUrl, apiKey, enabledToolNames: [] },
+            );
+            return r?.message?.content || "";
+          });
+        const { assessment } = await doAssess({
+          goal,
+          transcript: { prompt: options.prompt, finalText, toolCalls },
+          chat: assessChat,
+        });
+        if (assessment) {
+          if (isText) {
+            writeErr(
+              `  ◎ goal ${boundGoalId}: ${assessment.advanced ? "advanced" : "no progress"}` +
+                (assessment.progress != null
+                  ? ` (${assessment.progress}%)`
+                  : "") +
+                "\n",
+            );
+          }
+          emitStream({
+            type: "goal_assessment",
+            goal_id: boundGoalId,
+            advanced: assessment.advanced,
+            progress: assessment.progress,
+            note: assessment.note,
+          });
+        }
+      }
+    } catch {
+      /* assessment is best-effort — never affect the run outcome */
+    }
+  }
+
   if (isStream) {
     emitStream({
       type: "result",

package/src/runtime/headless-stream.js

@@ -207,6 +207,26 @@ export async function runAgentHeadlessStream(options = {}, deps = {}) {
     additional_directories: additionalDirectories,
   });
 
+  // Goal binding (cc goal, Phase 1) — resolved once and injected on every turn.
+  // `--goal <id>` binds explicitly; `--goal` with no value auto-resolves.
+  let goalPrepareCallFn;
+  if (options.goal !== undefined && options.goal !== false) {
+    try {
+      const explicitId = typeof options.goal === "string" ? options.goal : null;
+      const { resolveActiveGoal } = await import("../lib/goal-store.js");
+      const goal = (deps.resolveActiveGoal || resolveActiveGoal)({
+        explicitId,
+        sessionId,
+      });
+      if (goal) {
+        const { goalPrepareCall } = await import("../lib/goal-context.js");
+        goalPrepareCallFn = goalPrepareCall(goal);
+      }
+    } catch {
+      /* goal binding is best-effort — proceed without it */
+    }
+  }
+
   const loopOptionsBase = {
     model,
     provider,
@@ -219,6 +239,7 @@ export async function runAgentHeadlessStream(options = {}, deps = {}) {
     approvalGate,
     enabledToolNames,
     disabledTools,
+    prepareCall: goalPrepareCallFn,
     chatFn: deps.chatFn || options.chatFn || undefined,
     signal: options.signal || undefined,
     // --include-partial-messages: stream live assistant-text deltas as

package/src/runtime/mcp-config.js

@@ -0,0 +1,139 @@
+/**
+ * Ad-hoc MCP config loader for headless agent runs (`cc agent --mcp-config`).
+ *
+ * Claude-Code parity: load a JSON file describing MCP servers, connect them for
+ * the duration of one headless run, and expose each server's tools to the LLM.
+ *
+ * The agent loop already knows how to *call* an MCP tool — it just needs three
+ * things wired into its options (see agent-core.js):
+ *   - extraToolDefinitions     → the LLM sees the tools (OpenAI function shape)
+ *   - externalToolExecutors    → name → {kind:"mcp", serverName, toolName}
+ *   - mcpClient                → executes mcpClient.callTool(server, tool, args)
+ *
+ * Tools are namespaced `mcp__<server>__<tool>` (Claude-Code convention) so they
+ * never collide with built-in agent tools or across servers.
+ */
+
+import fs from "fs";
+import { MCPClient } from "../harness/mcp-client.js";
+
+/**
+ * Normalize a parsed config object into a `{ name: serverConfig }` map.
+ * Accepts the Claude-Code shape `{ "mcpServers": { ... } }`, the bundle shape
+ * `{ "servers": { ... } }`, or a bare `{ name: cfg }` map.
+ */
+export function parseMcpServers(raw) {
+  const block =
+    (raw && typeof raw === "object" && (raw.mcpServers || raw.servers)) ||
+    raw ||
+    {};
+  const out = {};
+  for (const [name, cfg] of Object.entries(block)) {
+    if (!cfg || typeof cfg !== "object") continue;
+    out[name] = {
+      command: cfg.command,
+      args: Array.isArray(cfg.args) ? cfg.args : [],
+      env: cfg.env && typeof cfg.env === "object" ? cfg.env : {},
+      url: cfg.url,
+      transport: cfg.transport,
+      headers: cfg.headers && typeof cfg.headers === "object" ? cfg.headers : {},
+    };
+  }
+  return out;
+}
+
+/** Namespaced tool name exposed to the LLM. */
+export function mcpToolName(server, tool) {
+  return `mcp__${server}__${tool}`;
+}
+
+/**
+ * Connect the given servers and build the agent-loop wiring. Connection
+ * failures are reported (writeErr) but never abort the run — a broken server
+ * just contributes no tools.
+ *
+ * @param {object} servers  `{ name: { command|url, args, env, transport, headers } }`
+ * @param {object} [deps]   { writeErr, createClient }
+ * @returns {Promise<{mcpClient, extraToolDefinitions, externalToolExecutors,
+ *                     externalToolDescriptors, connected}>}
+ */
+export async function setupMcpFromConfig(servers, deps = {}) {
+  const writeErr = deps.writeErr || (() => {});
+  const createClient = deps.createClient || (() => new MCPClient());
+
+  const mcpClient = createClient();
+  const extraToolDefinitions = [];
+  const externalToolExecutors = {};
+  const externalToolDescriptors = {};
+  const connected = [];
+
+  for (const [name, cfg] of Object.entries(servers)) {
+    let result;
+    try {
+      result = await mcpClient.connect(name, cfg);
+    } catch (err) {
+      writeErr(`  mcp: failed to connect "${name}": ${err.message}\n`);
+      continue;
+    }
+    const tools = Array.isArray(result?.tools) ? result.tools : [];
+    connected.push({ server: name, tools: tools.length });
+    for (const t of tools) {
+      if (!t || !t.name) continue;
+      const full = mcpToolName(name, t.name);
+      extraToolDefinitions.push({
+        type: "function",
+        function: {
+          name: full,
+          description: t.description || `MCP tool "${t.name}" on server "${name}"`,
+          parameters: t.inputSchema || { type: "object", properties: {} },
+        },
+      });
+      externalToolExecutors[full] = {
+        kind: "mcp",
+        serverName: name,
+        toolName: t.name,
+      };
+      externalToolDescriptors[full] = {
+        name: full,
+        kind: "mcp",
+        category: "mcp",
+        source: name,
+      };
+    }
+  }
+
+  return {
+    mcpClient,
+    extraToolDefinitions,
+    externalToolExecutors,
+    externalToolDescriptors,
+    connected,
+  };
+}
+
+/**
+ * Read + parse a `--mcp-config` file and connect its servers.
+ * Throws on an unreadable/empty config (fail fast — the user asked for MCP).
+ *
+ * @param {string} filePath
+ * @param {object} [deps]  { writeErr, createClient, readFile }
+ */
+export async function loadMcpConfig(filePath, deps = {}) {
+  const readFile = deps.readFile || ((p) => fs.readFileSync(p, "utf-8"));
+  let raw;
+  try {
+    raw = JSON.parse(readFile(filePath));
+  } catch (err) {
+    throw new Error(
+      `--mcp-config: cannot read/parse "${filePath}": ${err.message}`,
+    );
+  }
+  const servers = parseMcpServers(raw);
+  if (Object.keys(servers).length === 0) {
+    throw new Error(
+      `--mcp-config: no servers found in "${filePath}" ` +
+        `(expected {"mcpServers": {"name": {"command": "..."}}}).`,
+    );
+  }
+  return setupMcpFromConfig(servers, deps);
+}

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

@@ -1 +0,0 @@
-import{I as v,P as u,J as S,U as s,R as a,S as y,K as C,Q as x,V as w,_ as B,b as n}from"./vendor-BvqAck49.js";import{_ as k}from"./index-BItcSqan.js";import"./icons-DP3uiYxy.js";const M={__name:"ChatBubbleRenderer",props:{event:{type:Object,required:!0}},setup(c,{expose:d}){d();const t=c,r=n(()=>{const e=t.event.content||{};return e.text||e.body||e.message||e.title||JSON.stringify(e).slice(0,200)}),i=n(()=>{const e=t.event.content||{};return e.from||e.sender||e.senderName||t.event.actor||"(unknown)"}),l=n(()=>{const e=(t.event.actor||"").toLowerCase();return e.includes("self")||e==="me"||e.endsWith("_self")}),o=n(()=>{const e=t.event.source.adapter||"";return e.startsWith("messaging-qq")?"magenta":e==="wechat"?"green":"blue"}),m=n(()=>{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:n};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:B(["chat-row",{mine:r.isMine}])},[s("div",N,[s("div",T,[s("span",R,a(r.actorLabel),1),s("span",V,a(r.formattedTime),1)]),s("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 A=k(M,[["render",D],["__scopeId","data-v-49238629"],["__file","/tmp/cc-web-panel-v2hnMt/repo/packages/web-panel/src/components/pdh/renderers/ChatBubbleRenderer.vue"]]);export{A as default};

package/src/assets/web-panel/assets/MobileProjects-CrJJOCFw.js

@@ -1 +0,0 @@
-import{I as n,J as g,c as l,K as r,N as u,P as h,U as o,R as t,Q as b}from"./vendor-BvqAck49.js";import{_ as v,b as m}from"./index-BItcSqan.js";import{a7 as M,M as y}from"./icons-DP3uiYxy.js";const B={__name:"MobileProjects",setup(p,{expose:i}){i();const c=u(),{t:e}=m();function a(){c.push("/projects")}function _(){c.push("/mobile-bridge")}const s={router:c,t:e,goToProjects:a,goToMobileBridge:_,get useRouter(){return u},get useI18n(){return m},get MobileOutlined(){return y},get FolderOutlined(){return M}};return Object.defineProperty(s,"__isScriptSetup",{enumerable:!1,value:!0}),s}},x={class:"mobile-projects-placeholder"},O={class:"title"},k={class:"subtitle"},w={class:"explainer"};function T(p,i,c,e,a,_){const s=n("a-alert"),d=n("a-button"),f=n("a-space"),P=n("a-empty"),j=n("a-card");return h(),g("div",x,[l(j,null,{default:r(()=>[l(P,{description:!1},{image:r(()=>[l(e.MobileOutlined,{style:{fontSize:"64px",color:"#bfbfbf"}})]),default:r(()=>[o("h2",O,t(e.t("mobileProjects.title")),1),o("p",k,t(e.t("mobileProjects.subtitle")),1),l(s,{message:e.t("mobileProjects.v02Banner"),type:"info","show-icon":"",class:"banner"},null,8,["message"]),o("div",w,[o("h3",null,t(e.t("mobileProjects.currentDirection")),1),o("p",null,t(e.t("mobileProjects.currentDirectionBody")),1),o("ul",null,[o("li",null,t(e.t("mobileProjects.stepPhone")),1),o("li",null,t(e.t("mobileProjects.stepTap")),1),o("li",null,t(e.t("mobileProjects.stepPull")),1)]),o("h3",null,t(e.t("mobileProjects.reverseDirection")),1),o("p",null,t(e.t("mobileProjects.reverseDirectionBody")),1)]),l(f,{class:"actions"},{default:r(()=>[l(d,{type:"primary",onClick:e.goToProjects},{default:r(()=>[l(e.FolderOutlined),b(" "+t(e.t("mobileProjects.viewLocalProjects")),1)]),_:1}),l(d,{onClick:e.goToMobileBridge},{default:r(()=>[l(e.MobileOutlined),b(" "+t(e.t("mobileProjects.checkBridge")),1)]),_:1})]),_:1})]),_:1})]),_:1})])}const N=v(B,[["render",T],["__scopeId","data-v-9262cc45"],["__file","/tmp/cc-web-panel-v2hnMt/repo/packages/web-panel/src/views/MobileProjects.vue"]]);export{N as default};

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

@@ -1 +0,0 @@
-import{I as w,P as l,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-BvqAck49.js";import{_ as S}from"./index-BItcSqan.js";import"./icons-DP3uiYxy.js";const k={__name:"OrderTableRenderer",props:{event:{type:Object,required:!0}},setup(p,{expose:r}){r();const o=p,e=a(()=>o.event.content||{}),d=a(()=>o.event.extra||{}),m=a(()=>d.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(()=>d.value.orderNo||e.value.orderNo||e.value.orderId),f=a(()=>e.value.status||e.value.state),h=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"}),b=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:d,merchantText:m,itemText:c,amountText:y,orderNo:T,statusText:f,statusColor:h,formattedTime:b,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"},M={class:"val amount"},j={key:0,class:"row"},A={class:"val mono"},F={key:1,class:"row"};function P(p,r,o,e,d,m){const c=w("a-tag");return l(),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",M,n(e.amountText),1)]),e.orderNo?(l(),u("div",j,[r[3]||(r[3]=s("span",{class:"key"},"单号",-1)),s("span",A,n(e.orderNo),1)])):g("v-if",!0),e.statusText?(l(),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 K=S(k,[["render",P],["__scopeId","data-v-5ed5524d"],["__file","/tmp/cc-web-panel-v2hnMt/repo/packages/web-panel/src/components/pdh/renderers/OrderTableRenderer.vue"]]);export{K as default};