mango-cms 0.3.33 → 0.3.35

package/lib/vibe-orchestrator/src/streamParser.js

@@ -0,0 +1,188 @@
+// streamParser.js
+//
+// Parses Claude Code headless `--output-format stream-json` output into a
+// normalized stream of progress events the front-end can render.
+//
+// Claude Code emits newline-delimited JSON (NDJSON). stdout chunks can split a
+// line anywhere, so we buffer until we see a newline. Each complete line is one
+// JSON object; we normalize the shapes we care about and pass everything else
+// through as `unknown` so nothing is silently dropped.
+//
+// Known top-level message types (Claude Code v2.x):
+//   { type: "system", subtype: "init", session_id, model, tools, cwd, ... }
+//   { type: "assistant", message: { content: [...], usage: {...} }, session_id }
+//   { type: "user",      message: { content: [tool_result ...] }, session_id }
+//   { type: "result",    subtype, total_cost_usd, duration_ms, usage, result, session_id }
+//
+// Pure module: no I/O, no process access. Fully unit-testable without a token.
+
+/**
+ * @typedef {Object} ProgressEvent
+ * @property {string} kind   - normalized event kind (see below)
+ * @property {number} [ts]   - caller-supplied timestamp (parser never reads the clock)
+ */
+
+const KINDS = Object.freeze({
+  SESSION_START: 'session_start',
+  ASSISTANT_TEXT: 'assistant_text',
+  THINKING: 'thinking',
+  TOOL_USE: 'tool_use',
+  TOOL_RESULT: 'tool_result',
+  RESULT: 'result',
+  PARSE_ERROR: 'parse_error',
+  UNKNOWN: 'unknown',
+})
+
+/** Pull a normalized usage object out of whatever shape it arrives in. */
+function normalizeUsage(usage) {
+  if (!usage || typeof usage !== 'object') return null
+  const freshInput = usage.input_tokens || 0
+  const cacheCreation = usage.cache_creation_input_tokens || 0
+  const cacheRead = usage.cache_read_input_tokens || 0
+  const input = freshInput + cacheCreation + cacheRead
+  const output = usage.output_tokens || 0
+  return {
+    inputTokens: input,            // total input incl. cached context (display)
+    outputTokens: output,
+    cacheReadTokens: cacheRead,
+    totalTokens: input + output,   // full token volume (display)
+    // What actually counts against the per-session cap: NEW tokens only. The
+    // cached context (cache_read) is re-reported on every turn and is cheap
+    // already-paid context — summing it across turns balloons the count and
+    // would trip the cap on a trivial multi-turn edit. Exclude it.
+    billableTokens: freshInput + cacheCreation + output,
+    raw: usage,
+  }
+}
+
+/** Normalize a single already-parsed NDJSON object into 0+ progress events. */
+function normalizeMessage(msg) {
+  if (!msg || typeof msg !== 'object') {
+    return [{ kind: KINDS.UNKNOWN, raw: msg }]
+  }
+
+  switch (msg.type) {
+    case 'system':
+      if (msg.subtype === 'init') {
+        return [{
+          kind: KINDS.SESSION_START,
+          sessionId: msg.session_id || null,
+          model: msg.model || null,
+          tools: Array.isArray(msg.tools) ? msg.tools : [],
+          cwd: msg.cwd || null,
+        }]
+      }
+      return [{ kind: KINDS.UNKNOWN, raw: msg }]
+
+    case 'assistant': {
+      const content = msg.message?.content
+      const usage = normalizeUsage(msg.message?.usage)
+      const events = []
+      if (Array.isArray(content)) {
+        for (const block of content) {
+          if (block.type === 'text' && block.text) {
+            events.push({ kind: KINDS.ASSISTANT_TEXT, text: block.text })
+          } else if (block.type === 'thinking' && block.thinking) {
+            events.push({ kind: KINDS.THINKING, text: block.thinking })
+          } else if (block.type === 'tool_use') {
+            events.push({
+              kind: KINDS.TOOL_USE,
+              tool: block.name,
+              toolId: block.id,
+              input: block.input,
+            })
+          }
+        }
+      }
+      // An assistant turn with usage but no renderable block still carries token
+      // accounting we must not lose — emit a bare usage-only event.
+      if (events.length === 0 && usage) {
+        events.push({ kind: KINDS.ASSISTANT_TEXT, text: '' })
+      }
+      // One assistant message == one model API call == one usage report. Attach
+      // usage to the FIRST event only so the token meter counts it once per turn,
+      // not once per content block (a turn may carry text + tool_use together).
+      if (events.length && usage) events[0].usage = usage
+      return events
+    }
+
+    case 'user': {
+      const content = msg.message?.content
+      const events = []
+      if (Array.isArray(content)) {
+        for (const block of content) {
+          if (block.type === 'tool_result') {
+            events.push({
+              kind: KINDS.TOOL_RESULT,
+              toolId: block.tool_use_id,
+              isError: !!block.is_error,
+              content: block.content,
+            })
+          }
+        }
+      }
+      return events.length ? events : [{ kind: KINDS.UNKNOWN, raw: msg }]
+    }
+
+    case 'result':
+      return [{
+        kind: KINDS.RESULT,
+        subtype: msg.subtype || null,
+        isError: !!msg.is_error,
+        durationMs: msg.duration_ms ?? null,
+        costUsd: msg.total_cost_usd ?? null,
+        usage: normalizeUsage(msg.usage),
+        numTurns: msg.num_turns ?? null,
+        sessionId: msg.session_id || null,
+        result: typeof msg.result === 'string' ? msg.result : null,
+      }]
+
+    default:
+      return [{ kind: KINDS.UNKNOWN, raw: msg }]
+  }
+}
+
+/**
+ * Stateful NDJSON line buffer. Feed it raw stdout chunks; it returns the
+ * normalized progress events for every *complete* line seen so far.
+ */
+class StreamParser {
+  constructor() {
+    this.buffer = ''
+  }
+
+  /**
+   * @param {string|Buffer} chunk
+   * @returns {ProgressEvent[]}
+   */
+  push(chunk) {
+    this.buffer += chunk.toString()
+    const events = []
+    let nl
+    while ((nl = this.buffer.indexOf('\n')) !== -1) {
+      const line = this.buffer.slice(0, nl).trim()
+      this.buffer = this.buffer.slice(nl + 1)
+      if (line) events.push(...this._parseLine(line))
+    }
+    return events
+  }
+
+  /** Flush any trailing partial line at stream end. */
+  flush() {
+    const line = this.buffer.trim()
+    this.buffer = ''
+    return line ? this._parseLine(line) : []
+  }
+
+  _parseLine(line) {
+    let parsed
+    try {
+      parsed = JSON.parse(line)
+    } catch {
+      return [{ kind: KINDS.PARSE_ERROR, raw: line }]
+    }
+    return normalizeMessage(parsed)
+  }
+}
+
+export { StreamParser, normalizeMessage, normalizeUsage, KINDS }

package/lib/vibe-orchestrator/src/tokenMeter.js

@@ -0,0 +1,64 @@
+// tokenMeter.js
+//
+// Cumulative token accounting + per-session cap. Fed the `usage` objects that
+// streamParser attaches to assistant events. Pure/in-memory: one instance per
+// session.
+//
+// The cap counts BILLABLE tokens (new input + cache creation + output), NOT the
+// full `totalTokens` — Claude Code re-reports the whole cached context
+// (cache_read) on every turn, so summing totals across turns balloons the count
+// and would trip the cap on a trivial multi-turn edit. We still track the full
+// volume for display.
+
+class TokenMeter {
+  /** @param {number} cap - max cumulative BILLABLE tokens before tripping (0 = unlimited) */
+  constructor(cap = 0) {
+    this.cap = cap > 0 ? cap : 0
+    this.inputTokens = 0      // full input incl. re-read cache (display)
+    this.outputTokens = 0
+    this.cacheReadTokens = 0  // re-read cached context (display / cost breakdown)
+    this.billableTokens = 0   // new input + cache creation + output (cap basis)
+  }
+
+  get totalTokens() {
+    return this.inputTokens + this.outputTokens
+  }
+
+  /**
+   * Record one assistant turn's usage. Returns true if the cap is now exceeded.
+   * Accepts the normalized usage from streamParser; falls back to totalTokens
+   * when billableTokens is absent (older callers / hand-built usage in tests).
+   * @param {{inputTokens?:number, outputTokens?:number, totalTokens?:number, billableTokens?:number}|null} usage
+   */
+  record(usage) {
+    if (!usage) return this.exceeded
+    this.inputTokens += usage.inputTokens || 0
+    this.outputTokens += usage.outputTokens || 0
+    this.cacheReadTokens += usage.cacheReadTokens || 0
+    const billable = usage.billableTokens != null
+      ? usage.billableTokens
+      : (usage.totalTokens != null
+        ? usage.totalTokens
+        : (usage.inputTokens || 0) + (usage.outputTokens || 0))
+    this.billableTokens += billable
+    return this.exceeded
+  }
+
+  get exceeded() {
+    return this.cap > 0 && this.billableTokens >= this.cap
+  }
+
+  snapshot() {
+    return {
+      inputTokens: this.inputTokens,
+      outputTokens: this.outputTokens,
+      cacheReadTokens: this.cacheReadTokens,
+      totalTokens: this.totalTokens,
+      billableTokens: this.billableTokens,
+      cap: this.cap,
+      exceeded: this.exceeded,
+    }
+  }
+}
+
+export { TokenMeter }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mango-cms",
-  "version": "0.3.33",
+  "version": "0.3.35",
   "type": "module",
   "main": "./index.js",
   "exports": {

package/readme.md

@@ -2,6 +2,12 @@
 
 Mango is a powerful, code-first CMS built on MongoDB that emphasizes configuration through code. This documentation covers how to configure and use Mango CMS through the `config` folder.
 
+> **Vibe (in-page AI coding):** to activate the optional ⌘K "edit your live site"
+> experience on a Mango project, follow [docs/VIBE_ACTIVATION.md](docs/VIBE_ACTIVATION.md)
+> — install/upgrade → flip `settings.vibe.enabled` → set `VITE_VIBE_SHELL` → run
+> the bundled orchestrator + gateway behind the infra templates in
+> [default/infra/vibe/](default/infra/vibe/). No source copying required.
+
 ## Table of Contents
 
 1. [Collections](#collections)