cx-viewer 1.0.0

package/lib/file-api.js

@@ -0,0 +1,128 @@
+/**
+ * File API business logic — extracted from server.js
+ * Provides path validation, file read/write with security checks.
+ */
+import { resolve, join } from 'node:path';
+import { realpathSync, existsSync, statSync, readFileSync, writeFileSync } from 'node:fs';
+
+/**
+ * Check whether targetPath is contained within the project root directory.
+ * Resolves symlinks via realpathSync. Returns false on any error.
+ * @param {string} targetPath - absolute path to check
+ * @param {string} [root] - project root (defaults to CXV_PROJECT_DIR or cwd)
+ * @returns {boolean}
+ */
+export function isPathContained(targetPath, root) {
+  try {
+    const resolvedRoot = realpathSync(resolve(root || process.env.CXV_PROJECT_DIR || process.cwd()));
+    const real = realpathSync(resolve(targetPath));
+    return real === resolvedRoot || real.startsWith(resolvedRoot + '/');
+  } catch { return false; }
+}
+
+/** Custom error with a code property for HTTP status mapping */
+class FileApiError extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+}
+
+/**
+ * Resolve and validate a file path. Used by readFileContent and file-raw handler.
+ * @param {string} cwd - project working directory
+ * @param {string} reqPath - requested path (relative or absolute)
+ * @param {boolean} isEditorSession - whether this is an editor session
+ * @returns {string} resolved absolute file path
+ * @throws {FileApiError} with code 'INVALID_PATH'
+ */
+export function resolveFilePath(cwd, reqPath, isEditorSession) {
+  if (!reqPath) {
+    throw new FileApiError('INVALID_PATH', 'Invalid path');
+  }
+  if (!isEditorSession && (reqPath.startsWith('/') || reqPath.includes('..'))) {
+    const resolved = resolve(reqPath.startsWith('/') ? reqPath : join(cwd, reqPath));
+    if (!isPathContained(resolved, cwd)) {
+      throw new FileApiError('INVALID_PATH', 'Invalid path');
+    }
+    return resolve(resolved);
+  }
+  return resolve((isEditorSession && reqPath.startsWith('/')) ? reqPath : join(cwd, reqPath));
+}
+
+/**
+ * Read file content with size limit and security checks.
+ * @param {string} cwd - project working directory
+ * @param {string} reqPath - requested path
+ * @param {boolean} isEditorSession
+ * @returns {{ path: string, content: string, size: number }}
+ */
+export function readFileContent(cwd, reqPath, isEditorSession) {
+  if (!reqPath) {
+    throw new FileApiError('INVALID_PATH', 'Invalid path');
+  }
+
+  // For non-editor sessions with absolute / ".." paths that are within project dir,
+  // return the relative path from project root
+  if (!isEditorSession && (reqPath.startsWith('/') || reqPath.includes('..'))) {
+    const resolved = resolve(reqPath);
+    if (isPathContained(resolved, cwd)) {
+      const root = realpathSync(resolve(cwd));
+      const relPath = realpathSync(resolved).slice(root.length + 1);
+      const targetFile = realpathSync(resolved);
+      return _readAndReturn(targetFile, relPath);
+    }
+    throw new FileApiError('INVALID_PATH', 'Invalid path');
+  }
+
+  const targetFile = (isEditorSession && reqPath.startsWith('/')) ? reqPath : join(cwd, reqPath);
+  return _readAndReturn(targetFile, reqPath);
+}
+
+function _readAndReturn(targetFile, displayPath) {
+  if (!existsSync(targetFile)) {
+    throw new FileApiError('NOT_FOUND', `File not found: ${targetFile}`);
+  }
+  const stat = statSync(targetFile);
+  if (!stat.isFile()) {
+    throw new FileApiError('NOT_FILE', 'Not a file');
+  }
+  if (stat.size > 5 * 1024 * 1024) {
+    throw new FileApiError('TOO_LARGE', 'File too large');
+  }
+  const content = readFileSync(targetFile, 'utf-8');
+  return { path: displayPath, content, size: stat.size };
+}
+
+/**
+ * Write file content.
+ * @param {string} cwd - project working directory
+ * @param {string} reqPath - requested path
+ * @param {string} content - file content to write
+ * @param {boolean} isEditorSession
+ * @returns {{ path: string, size: number }}
+ */
+export function writeFileContent(cwd, reqPath, content, isEditorSession) {
+  if (!reqPath) {
+    throw new FileApiError('INVALID_PATH', 'Invalid path');
+  }
+  if (!isEditorSession && (reqPath.startsWith('/') || reqPath.includes('..'))) {
+    throw new FileApiError('INVALID_PATH', 'Invalid path');
+  }
+  if (typeof content !== 'string') {
+    throw new FileApiError('INVALID_CONTENT', 'Content must be a string');
+  }
+  const targetFile = (isEditorSession && reqPath.startsWith('/')) ? reqPath : join(cwd, reqPath);
+  writeFileSync(targetFile, content, 'utf-8');
+  const stat = statSync(targetFile);
+  return { path: reqPath, size: stat.size };
+}
+
+/** Map FileApiError codes to HTTP status codes */
+export const ERROR_STATUS_MAP = {
+  INVALID_PATH: 400,
+  NOT_FOUND: 404,
+  NOT_FILE: 400,
+  TOO_LARGE: 413,
+  INVALID_CONTENT: 400,
+};

package/lib/git-diff.js

@@ -0,0 +1,89 @@
+import { readFileSync, existsSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+
+const execFileAsync = promisify(execFile);
+
+/**
+ * Get git diffs for a list of files.
+ * @param {string} cwd - working directory (git repo root)
+ * @param {string[]} files - relative file paths
+ * @returns {Promise<Array>} diffs array
+ */
+export async function getGitDiffs(cwd, files) {
+  const diffs = [];
+
+  for (const file of files) {
+    // 安全检查：防止路径穿越
+    if (file.includes('..') || file.startsWith('/')) continue;
+
+    try {
+      const { stdout: statusOutput } = await execFileAsync('git', ['status', '--porcelain', '--', file], { cwd, encoding: 'utf-8', timeout: 3000 });
+      if (!statusOutput.trim()) continue;
+
+      const status = statusOutput.substring(0, 2).trim();
+      const is_new = status === 'A' || status === '??';
+      const is_deleted = status === 'D';
+
+      // 检查是否为二进制文件（已删除文件跳过）
+      let is_binary = false;
+      if (!is_deleted) {
+        try {
+          const { stdout: diffCheck } = await execFileAsync('git', ['diff', '--numstat', 'HEAD', '--', file], { cwd, encoding: 'utf-8', timeout: 3000 });
+          if (diffCheck.includes('-\t-\t')) {
+            is_binary = true;
+          }
+        } catch {}
+      }
+
+      let old_content = '';
+      let new_content = '';
+
+      if (!is_binary) {
+        // 获取旧内容（HEAD 版本）
+        if (!is_new) {
+          try {
+            const { stdout } = await execFileAsync('git', ['show', `HEAD:${file}`], { cwd, encoding: 'utf-8', timeout: 5000, maxBuffer: 5 * 1024 * 1024 });
+            old_content = stdout;
+          } catch {
+            old_content = '';
+          }
+        }
+
+        // 获取新内容（工作区版本）
+        if (!is_deleted) {
+          try {
+            const filePath = join(cwd, file);
+            if (existsSync(filePath)) {
+              const stat = statSync(filePath);
+              if (stat.size > 5 * 1024 * 1024) {
+                // 文件过大
+                diffs.push({ file, status, is_large: true, size: stat.size });
+                continue;
+              }
+              new_content = readFileSync(filePath, 'utf-8');
+            }
+          } catch {
+            new_content = '';
+          }
+        }
+      }
+
+      diffs.push({
+        file,
+        status,
+        old_content,
+        new_content,
+        is_binary,
+        is_new,
+        is_deleted
+      });
+    } catch (err) {
+      // 跳过无法处理的文件
+      continue;
+    }
+  }
+
+  return diffs;
+}

package/lib/interceptor-core.js

@@ -0,0 +1,270 @@
+import { appendFileSync, existsSync, readdirSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+const SUBAGENT_SYSTEM_RE = /(?:command execution|file search|planning) specialist|general-purpose agent/i;
+
+export function getSystemText(body) {
+  const system = body?.system;
+  if (typeof system === 'string') return system;
+  if (Array.isArray(system)) {
+    return system.map(s => (s && s.text) || '').join('');
+  }
+  return '';
+}
+
+export function isMainAgentRequest(body) {
+  if (!body?.system || !Array.isArray(body?.tools)) return false;
+
+  const sysText = getSystemText(body);
+  if (!sysText.includes('You are Codex')) return false;
+  if (SUBAGENT_SYSTEM_RE.test(sysText)) return false;
+
+  const isSystemArray = Array.isArray(body.system);
+  const hasToolSearch = body.tools.some(t => t.name === 'ToolSearch');
+
+  if (isSystemArray && hasToolSearch) {
+    const messages = body.messages || [];
+    const firstMsgContent = messages.length > 0 ?
+      (typeof messages[0].content === 'string' ? messages[0].content :
+        Array.isArray(messages[0].content) ? messages[0].content.map(c => c.text || '').join('') : '') : '';
+    if (firstMsgContent.includes('<available-deferred-tools>')) {
+      return true;
+    }
+  }
+
+  // v2.1.81+: 轻量 MainAgent 初始请求工具数可能 < 10，降低阈值兼容
+  if (body.tools.length > 5) {
+    const hasEdit = body.tools.some(t => t.name === 'Edit');
+    const hasBash = body.tools.some(t => t.name === 'Bash');
+    const hasTaskOrAgent = body.tools.some(t => t.name === 'Task' || t.name === 'Agent');
+    if (hasEdit && hasBash && hasTaskOrAgent) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+export function isPreflightEntry(entry) {
+  if (entry.mainAgent || entry.isHeartbeat || entry.isCountTokens) return false;
+  const body = entry.body || {};
+  if (Array.isArray(body.tools) && body.tools.length > 0) return false;
+  const msgs = body.messages || [];
+  if (msgs.length !== 1 || msgs[0].role !== 'user') return false;
+  const sysText = typeof body.system === 'string' ? body.system :
+    Array.isArray(body.system) ? body.system.map(s => s?.text || '').join('') : '';
+  return sysText.includes('Codex');
+}
+
+export function isOpenAiApiPath(urlStr) {
+  try {
+    const pathname = new URL(urlStr).pathname;
+    return /^\/v1\/messages(\/count_tokens)?$/.test(pathname)
+      || /^\/v1\/chat\/completions$/.test(pathname)
+      || /^\/v1\/completions$/.test(pathname)
+      || /^\/v1\/embeddings$/.test(pathname)
+      || /^\/v1\/batches(\/.*)?$/.test(pathname);
+  } catch {
+    return /\/v1\/messages/.test(urlStr) || /\/v1\/chat\/completions/.test(urlStr);
+  }
+}
+
+
+export function assembleStreamMessage(events) {
+  let message = null;
+  const contentBlocks = [];
+  let currentBlockIndex = -1;
+
+  for (const event of events) {
+    if (!event || typeof event !== 'object' || !event.type) continue;
+
+    switch (event.type) {
+      case 'message_start':
+        message = { ...event.message };
+        message.content = [];
+        break;
+
+      case 'content_block_start':
+        currentBlockIndex = event.index;
+        contentBlocks[currentBlockIndex] = { ...event.content_block };
+        if (contentBlocks[currentBlockIndex].type === 'text') {
+          contentBlocks[currentBlockIndex].text = '';
+        } else if (contentBlocks[currentBlockIndex].type === 'thinking') {
+          contentBlocks[currentBlockIndex].thinking = '';
+        }
+        break;
+
+      case 'content_block_delta':
+        if (event.index >= 0 && contentBlocks[event.index] && event.delta) {
+          if (event.delta.type === 'text_delta' && event.delta.text) {
+            contentBlocks[event.index].text += event.delta.text;
+          } else if (event.delta.type === 'input_json_delta' && event.delta.partial_json) {
+            if (typeof contentBlocks[event.index]._inputJson !== 'string') {
+              contentBlocks[event.index]._inputJson = '';
+            }
+            contentBlocks[event.index]._inputJson += event.delta.partial_json;
+          } else if (event.delta.type === 'thinking_delta' && event.delta.thinking) {
+            contentBlocks[event.index].thinking += event.delta.thinking;
+          } else if (event.delta.type === 'signature_delta' && event.delta.signature) {
+            contentBlocks[event.index].signature = event.delta.signature;
+          }
+        }
+        break;
+
+      case 'content_block_stop':
+        if (event.index >= 0 && contentBlocks[event.index]) {
+          if (contentBlocks[event.index].type === 'tool_use' && typeof contentBlocks[event.index]._inputJson === 'string') {
+            try {
+              contentBlocks[event.index].input = JSON.parse(contentBlocks[event.index]._inputJson);
+            } catch {
+              contentBlocks[event.index].input = contentBlocks[event.index]._inputJson;
+            }
+            delete contentBlocks[event.index]._inputJson;
+          }
+        }
+        break;
+
+      case 'message_delta':
+        if (message && event.delta) {
+          if (event.delta.stop_reason) {
+            message.stop_reason = event.delta.stop_reason;
+          }
+          if (event.delta.stop_sequence !== undefined) {
+            message.stop_sequence = event.delta.stop_sequence;
+          }
+        }
+        if (message && event.usage) {
+          message.usage = { ...message.usage, ...event.usage };
+        }
+        break;
+
+      case 'message_stop':
+        break;
+    }
+  }
+
+  if (message) {
+    message.content = contentBlocks.filter(block => block !== undefined);
+  }
+
+  return message;
+}
+
+export function findRecentLog(dir, projectName) {
+  try {
+    const files = readdirSync(dir)
+      .filter(f => f.startsWith(projectName + '_') && f.endsWith('.jsonl'))
+      .sort()
+      .reverse();
+    if (files.length === 0) return null;
+    return join(dir, files[0]);
+  } catch (err) {
+    if (process.env.CXV_DEBUG) console.warn('[CX-Viewer] findRecentLog error:', err.message);
+  }
+  return null;
+}
+
+export function cleanupTempFiles(dir, projectName) {
+  try {
+    const tempFiles = readdirSync(dir)
+      .filter(f => f.startsWith(projectName + '_') && f.endsWith('_temp.jsonl'));
+    for (const f of tempFiles) {
+      try {
+        const tempPath = join(dir, f);
+        const newPath = tempPath.replace('_temp.jsonl', '.jsonl');
+        if (existsSync(newPath)) {
+          const tempContent = readFileSync(tempPath, 'utf-8');
+          if (tempContent.trim()) {
+            appendFileSync(newPath, tempContent);
+          }
+          unlinkSync(tempPath);
+        } else {
+          // 只有非空 temp 文件才 rename，空文件直接删除
+          const sz = statSync(tempPath).size;
+          if (sz > 0) {
+            renameSync(tempPath, newPath);
+          } else {
+            unlinkSync(tempPath);
+          }
+        }
+      } catch { }
+    }
+  } catch { }
+}
+
+export function migrateConversationContext(oldFile, newFile) {
+  try {
+    const content = readFileSync(oldFile, 'utf-8');
+    if (!content.trim()) return;
+
+    const parts = content.split('\n---\n').filter(p => p.trim());
+    if (parts.length === 0) return;
+
+    let originIndex = -1;
+    for (let i = parts.length - 1; i >= 0; i--) {
+      if (!/"mainAgent"\s*:\s*true/.test(parts[i])) continue;
+      try {
+        const entry = JSON.parse(parts[i]);
+        if (entry.mainAgent) {
+          const msgs = entry.body?.messages;
+          // Delta storage: 使用 _totalMessageCount（delta 条目）或 msgs.length（旧格式）
+          const msgCount = entry._totalMessageCount || (Array.isArray(msgs) ? msgs.length : 0);
+          if (msgCount === 1) {
+            originIndex = i;
+            break;
+          }
+        }
+      } catch { }
+    }
+
+    if (originIndex < 0) return;
+
+    let migrationStart = originIndex;
+    if (originIndex > 0) {
+      try {
+        const prevContent = parts[originIndex - 1];
+        if (prevContent.trim().startsWith('{')) {
+          const prev = JSON.parse(prevContent);
+          if (isPreflightEntry(prev)) {
+            migrationStart = originIndex - 1;
+          }
+        }
+      } catch { }
+    }
+
+    const migratedParts = parts.slice(migrationStart);
+    writeFileSync(newFile, migratedParts.join('\n---\n') + '\n---\n');
+
+    const remainingParts = parts.slice(0, migrationStart);
+    if (remainingParts.length > 0) {
+      writeFileSync(oldFile, remainingParts.join('\n---\n') + '\n---\n');
+    } else {
+      // 所有内容已迁移到新文件，清空旧文件（不能删除，watcher 需要检测 truncation 来触发轮转）
+      writeFileSync(oldFile, '');
+    }
+  } catch { }
+}
+
+/**
+ * Rotate log file when it exceeds maxSize.
+ * Creates an empty new file (no content migration) and appends '\n' to old file
+ * to trigger fs.watchFile callback for watcher migration.
+ *
+ * @param {string} currentFile - current log file path
+ * @param {string} newFile - new log file path to rotate to
+ * @param {number} maxSize - max file size in bytes
+ * @returns {{ rotated: boolean, oldFile?: string, newFile?: string }}
+ */
+export function rotateLogFile(currentFile, newFile, maxSize) {
+  try {
+    if (!existsSync(currentFile)) return { rotated: false };
+    const size = statSync(currentFile).size;
+    if (size < maxSize) return { rotated: false };
+    // 不迁移旧内容，创建空新文件（立即创建，避免 watcher 时序窗口）
+    try { writeFileSync(newFile, ''); } catch { }
+    // 触发旧文件 watcher 回调，使其检测到文件变更并切换到新文件
+    try { appendFileSync(currentFile, '\n'); } catch { }
+    return { rotated: true, oldFile: currentFile, newFile };
+  } catch { }
+  return { rotated: false };
+}

package/lib/kv-cache-analyzer.js

@@ -0,0 +1,164 @@
+/**
+ * Server-side KV-Cache content analyzer.
+ * Ported from src/utils/helpers.js + src/utils/contentFilter.js
+ */
+
+const SUBAGENT_SYSTEM_RE = /command execution specialist|file search specialist|planning specialist|general-purpose agent/i;
+const TEAMMATE_SYSTEM_RE = /running as an agent in a team|Agent Teammate Communication/i;
+
+function getSystemText(body) {
+  const system = body?.system;
+  if (typeof system === 'string') return system;
+  if (Array.isArray(system)) {
+    return system.map(s => (s && s.text) || '').join('');
+  }
+  return '';
+}
+
+/**
+ * Determine if a log entry is from the MainAgent (not a teammate or subagent).
+ */
+export function isMainAgentEntry(entry) {
+  if (!entry) return false;
+
+  // Teammate subprocess requests are not MainAgent
+  if (entry.teammate) return false;
+  const sysText = getSystemText(entry.body || {});
+  if (TEAMMATE_SYSTEM_RE.test(sysText)) return false;
+
+  if (entry.mainAgent === true) {
+    if (SUBAGENT_SYSTEM_RE.test(sysText)) return false;
+    return true;
+  }
+
+  // Fallback detection for entries without mainAgent flag
+  const body = entry.body || {};
+  if (!body.system || !Array.isArray(body.tools)) return false;
+
+  if (!sysText.includes('You are Codex')) return false;
+  if (SUBAGENT_SYSTEM_RE.test(sysText)) return false;
+
+  // New architecture (v2.1.69+): deferred tool loading
+  const isSystemArray = Array.isArray(body.system);
+  const hasToolSearch = body.tools.some(t => t.name === 'ToolSearch');
+  if (isSystemArray && hasToolSearch) {
+    const messages = body.messages || [];
+    const firstMsgContent = messages.length > 0
+      ? (typeof messages[0].content === 'string' ? messages[0].content
+        : Array.isArray(messages[0].content) ? messages[0].content.map(c => c.text || '').join('') : '')
+      : '';
+    if (firstMsgContent.includes('<available-deferred-tools>')) return true;
+  }
+
+  // v2.1.81+: lightweight MainAgent may have < 10 tools, lowered threshold
+  if (body.tools.length > 5) {
+    const hasEdit = body.tools.some(t => t.name === 'Edit');
+    const hasBash = body.tools.some(t => t.name === 'Bash');
+    const hasTaskOrAgent = body.tools.some(t => t.name === 'Task' || t.name === 'Agent');
+    if (hasEdit && hasBash && hasTaskOrAgent) return true;
+  }
+
+  return false;
+}
+
+/**
+ * Extract text from a tool_result content block.
+ */
+export function extractToolResultText(toolResult) {
+  if (!toolResult.content) return String(toolResult.content ?? '');
+  if (typeof toolResult.content === 'string') return toolResult.content;
+  if (Array.isArray(toolResult.content)) {
+    return toolResult.content
+      .filter(b => b.type === 'text')
+      .map(b => b.text)
+      .join('\n');
+  }
+  return JSON.stringify(toolResult.content);
+}
+
+/**
+ * Extract cached content from a single log entry (MainAgent or SubAgent).
+ * Returns null if the entry has no body; returns object with empty arrays
+ * if no cache_control markers are found.
+ */
+export function extractCachedContent(entry) {
+  if (!entry?.body) return null;
+
+  const body = entry.body;
+  const usage = entry.response?.body?.usage;
+
+  const result = {
+    system: [],
+    messages: [],
+    tools: [],
+    cacheCreateTokens: usage?.cache_creation_input_tokens || 0,
+    cacheReadTokens: usage?.cache_read_input_tokens || 0,
+  };
+
+  // system: find last block with cache_control, collect 0..lastIndex
+  if (Array.isArray(body.system)) {
+    let lastCacheIndex = -1;
+    for (let i = body.system.length - 1; i >= 0; i--) {
+      if (body.system[i].cache_control) { lastCacheIndex = i; break; }
+    }
+    if (lastCacheIndex >= 0) {
+      for (let i = 0; i <= lastCacheIndex; i++) {
+        const block = body.system[i];
+        if (block.type === 'text' && block.text) result.system.push(block.text);
+      }
+    }
+  }
+
+  // messages: find last message with cache_control in content, collect 0..lastIndex
+  // Fallback: delta reconstruction + slim restore may lose cache_control markers,
+  // but cacheReadTokens > 0 proves messages were cached — extract all as approximation
+  if (Array.isArray(body.messages)) {
+    let lastCacheIndex = -1;
+    for (let i = body.messages.length - 1; i >= 0; i--) {
+      const content = body.messages[i].content;
+      if (Array.isArray(content)) {
+        for (const block of content) {
+          if (block.cache_control) { lastCacheIndex = i; break; }
+        }
+        if (lastCacheIndex >= 0) break;
+      }
+    }
+    if (lastCacheIndex < 0 && result.cacheReadTokens > 0 && body.messages.length > 0) {
+      lastCacheIndex = body.messages.length - 1;
+    }
+    if (lastCacheIndex >= 0) {
+      for (let i = 0; i <= lastCacheIndex; i++) {
+        const msg = body.messages[i];
+        const content = msg.content;
+        if (typeof content === 'string') {
+          result.messages.push(`[${msg.role}] ${content}`);
+        } else if (Array.isArray(content)) {
+          for (const block of content) {
+            if (block.type === 'text' && block.text) {
+              result.messages.push(`[${msg.role}] ${block.text}`);
+            } else if (block.type === 'tool_use') {
+              const inputStr = block.input ? JSON.stringify(block.input) : '';
+              const preview = inputStr.length > 200 ? inputStr.substring(0, 200) + '...' : inputStr;
+              result.messages.push(`[${msg.role}] ${block.name}(${preview})`);
+            } else if (block.type === 'tool_result') {
+              const toolText = extractToolResultText(block);
+              if (toolText) result.messages.push(`[tool_result: ${block.tool_use_id}] ${toolText}`);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // tools: API caches in order tools → system → messages.
+  // Tools are implicitly cached as part of the prefix (no cache_control needed on tools themselves).
+  // Show tools when system has cached content (indicating a cache prefix exists).
+  // Keep in sync with src/utils/helpers.js extractCachedContent
+  if (Array.isArray(body.tools) && body.tools.length > 0 && result.system.length > 0) {
+    for (const tool of body.tools) {
+      result.tools.push(`${tool.name}: ${tool.description || ''}`);
+    }
+  }
+
+  return result;
+}