@lightcone-ai/daemon 0.9.78 → 0.10.0

package/mcp-servers/portfolio-analysis/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "portfolio-analysis-mcp-server",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "index.js",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "zod": "^4.3.6"
+  }
+}

package/mcp-servers/portfolio-read/core.js

@@ -0,0 +1,330 @@
+import { readFileSync } from 'fs';
+
+const DEFAULT_CURRENCY = 'CNY';
+const DEFAULT_SOURCE_RISK = 'normal';
+
+const HEADER_ALIASES = Object.freeze({
+  symbol: ['symbol', 'ticker', 'code', 'sec_code', 'security_code', '股票代码', '证券代码', '代码'],
+  name: ['name', 'asset_name', 'security_name', 'instrument_name', '股票名称', '证券名称', '名称'],
+  quantity: ['quantity', 'qty', 'shares', 'position', 'holding', '持仓', '持仓数量', '数量', '股数'],
+  avgCost: ['avg_cost', 'average_cost', 'cost', 'cost_price', 'avg_price', '买入均价', '成本价', '平均成本', '成本'],
+  marketPrice: ['market_price', 'price', 'last_price', 'close', '最新价', '现价', '市价'],
+  marketValue: ['market_value', 'value', 'position_value', 'market_cap', '市值', '持仓市值'],
+  costBasis: ['cost_basis', 'total_cost', 'position_cost', '成本市值', '持仓成本'],
+  sector: ['sector', 'industry', '行业', '板块'],
+  assetClass: ['asset_class', 'asset_type', '类别', '资产类别'],
+  currency: ['currency', 'ccy', '币种'],
+});
+
+function normalizeHeader(value) {
+  return String(value ?? '')
+    .replace(/^\uFEFF/, '')
+    .trim()
+    .toLowerCase()
+    .replace(/\s+/g, '_')
+    .replace(/[-/]+/g, '_');
+}
+
+function normalizeCell(value) {
+  return String(value ?? '').trim();
+}
+
+function sanitizeSymbol(value) {
+  const normalized = String(value ?? '').trim();
+  if (!normalized) return '';
+  return normalized.toUpperCase();
+}
+
+function toNumber(value) {
+  if (typeof value === 'number') return Number.isFinite(value) ? value : null;
+  const raw = normalizeCell(value);
+  if (!raw) return null;
+  const cleaned = raw
+    .replace(/,/g, '')
+    .replace(/\$/g, '')
+    .replace(/¥/g, '')
+    .replace(/％/g, '%');
+  const percent = cleaned.endsWith('%');
+  const numeric = Number(percent ? cleaned.slice(0, -1) : cleaned);
+  if (!Number.isFinite(numeric)) return null;
+  return percent ? numeric / 100 : numeric;
+}
+
+function round(value, digits = 6) {
+  if (!Number.isFinite(value)) return null;
+  const factor = 10 ** digits;
+  return Math.round(value * factor) / factor;
+}
+
+function countDelimiterOutsideQuotes(line, delimiter) {
+  let count = 0;
+  let inQuotes = false;
+  for (let i = 0; i < line.length; i += 1) {
+    const ch = line[i];
+    if (ch === '"') {
+      if (inQuotes && line[i + 1] === '"') {
+        i += 1;
+      } else {
+        inQuotes = !inQuotes;
+      }
+      continue;
+    }
+    if (!inQuotes && ch === delimiter) count += 1;
+  }
+  return count;
+}
+
+function detectDelimiter(csvText) {
+  const firstLine = String(csvText ?? '').split(/\r?\n/).find(line => line.trim().length > 0) ?? '';
+  const candidates = [',', '\t', ';', '|'];
+  let best = ',';
+  let bestCount = -1;
+  for (const candidate of candidates) {
+    const count = countDelimiterOutsideQuotes(firstLine, candidate);
+    if (count > bestCount) {
+      best = candidate;
+      bestCount = count;
+    }
+  }
+  return best;
+}
+
+function parseDelimitedRows(csvText, delimiter) {
+  const rows = [];
+  let row = [];
+  let cell = '';
+  let inQuotes = false;
+
+  for (let i = 0; i < csvText.length; i += 1) {
+    const ch = csvText[i];
+
+    if (ch === '"') {
+      if (inQuotes && csvText[i + 1] === '"') {
+        cell += '"';
+        i += 1;
+      } else {
+        inQuotes = !inQuotes;
+      }
+      continue;
+    }
+
+    if (!inQuotes && ch === delimiter) {
+      row.push(cell);
+      cell = '';
+      continue;
+    }
+
+    if (!inQuotes && (ch === '\n' || ch === '\r')) {
+      if (ch === '\r' && csvText[i + 1] === '\n') i += 1;
+      row.push(cell);
+      const hasData = row.some(item => normalizeCell(item).length > 0);
+      if (hasData) rows.push(row);
+      row = [];
+      cell = '';
+      continue;
+    }
+
+    cell += ch;
+  }
+
+  if (cell.length > 0 || row.length > 0) {
+    row.push(cell);
+    const hasData = row.some(item => normalizeCell(item).length > 0);
+    if (hasData) rows.push(row);
+  }
+
+  return rows;
+}
+
+function lookupValue(row, aliases) {
+  for (const alias of aliases) {
+    const normalized = normalizeHeader(alias);
+    if (Object.prototype.hasOwnProperty.call(row, normalized)) {
+      const value = row[normalized];
+      if (normalizeCell(value)) return value;
+    }
+  }
+  return '';
+}
+
+function normalizeRow(rawRow, index, { defaultCurrency }) {
+  const symbol = sanitizeSymbol(lookupValue(rawRow, HEADER_ALIASES.symbol));
+  if (!symbol) {
+    return {
+      holding: null,
+      warning: `row_${index + 1}: missing symbol/code, skipped`,
+    };
+  }
+
+  const quantity = toNumber(lookupValue(rawRow, HEADER_ALIASES.quantity));
+  const avgCost = toNumber(lookupValue(rawRow, HEADER_ALIASES.avgCost));
+  const marketPrice = toNumber(lookupValue(rawRow, HEADER_ALIASES.marketPrice));
+  let marketValue = toNumber(lookupValue(rawRow, HEADER_ALIASES.marketValue));
+  let costBasis = toNumber(lookupValue(rawRow, HEADER_ALIASES.costBasis));
+
+  if (marketValue == null && quantity != null && marketPrice != null) {
+    marketValue = quantity * marketPrice;
+  }
+  if (costBasis == null && quantity != null && avgCost != null) {
+    costBasis = quantity * avgCost;
+  }
+
+  const holding = {
+    symbol,
+    name: normalizeCell(lookupValue(rawRow, HEADER_ALIASES.name)) || symbol,
+    quantity: round(quantity, 6),
+    avg_cost: round(avgCost, 6),
+    market_price: round(marketPrice, 6),
+    market_value: round(marketValue, 2),
+    cost_basis: round(costBasis, 2),
+    sector: normalizeCell(lookupValue(rawRow, HEADER_ALIASES.sector)) || 'Unknown',
+    asset_class: normalizeCell(lookupValue(rawRow, HEADER_ALIASES.assetClass)) || 'equity',
+    currency: normalizeCell(lookupValue(rawRow, HEADER_ALIASES.currency)) || defaultCurrency,
+  };
+
+  return { holding, warning: null };
+}
+
+function summarizeHoldings(holdings) {
+  let totalMarketValue = 0;
+  let totalCostBasis = 0;
+  let missingMarketValue = 0;
+  let missingCostBasis = 0;
+
+  for (const holding of holdings) {
+    if (holding.market_value == null) {
+      missingMarketValue += 1;
+    } else {
+      totalMarketValue += holding.market_value;
+    }
+
+    if (holding.cost_basis == null) {
+      missingCostBasis += 1;
+    } else {
+      totalCostBasis += holding.cost_basis;
+    }
+  }
+
+  const hasPnl = holdings.length > 0 && missingMarketValue === 0 && missingCostBasis === 0;
+
+  return {
+    position_count: holdings.length,
+    total_market_value: round(totalMarketValue, 2),
+    total_cost_basis: round(totalCostBasis, 2),
+    unrealized_pnl: hasPnl ? round(totalMarketValue - totalCostBasis, 2) : null,
+    missing_market_value_count: missingMarketValue,
+    missing_cost_basis_count: missingCostBasis,
+  };
+}
+
+function rowsToObjects(rows) {
+  if (rows.length === 0) return [];
+  const headerRow = rows[0].map(item => normalizeHeader(item));
+  const objects = [];
+
+  for (let i = 1; i < rows.length; i += 1) {
+    const raw = rows[i];
+    const row = {};
+    for (let col = 0; col < headerRow.length; col += 1) {
+      const header = headerRow[col];
+      if (!header) continue;
+      row[header] = normalizeCell(raw[col] ?? '');
+    }
+    objects.push(row);
+  }
+
+  return objects;
+}
+
+export function parsePortfolioCsv(csvText, options = {}) {
+  const content = String(csvText ?? '').replace(/^\uFEFF/, '').trim();
+  if (!content) throw new Error('CSV content is empty');
+
+  const delimiter = options.delimiter || detectDelimiter(content);
+  const rows = parseDelimitedRows(content, delimiter);
+  if (rows.length < 2) {
+    throw new Error('CSV requires a header row and at least one data row');
+  }
+
+  const objects = rowsToObjects(rows);
+  const holdings = [];
+  const warnings = [];
+
+  for (let i = 0; i < objects.length; i += 1) {
+    const result = normalizeRow(objects[i], i, {
+      defaultCurrency: options.currency || DEFAULT_CURRENCY,
+    });
+    if (result.warning) warnings.push(result.warning);
+    if (result.holding) holdings.push(result.holding);
+  }
+
+  if (holdings.length === 0) {
+    throw new Error('No valid holdings parsed from CSV');
+  }
+
+  return {
+    source: 'csv',
+    source_name: options.sourceName || 'user_upload_csv',
+    source_risk: DEFAULT_SOURCE_RISK,
+    as_of: options.asOf || new Date().toISOString(),
+    currency: options.currency || DEFAULT_CURRENCY,
+    holdings,
+    summary: summarizeHoldings(holdings),
+    warnings,
+  };
+}
+
+export function normalizePortfolioSnapshot(snapshot, options = {}) {
+  const payload = snapshot && typeof snapshot === 'object' ? snapshot : {};
+  const rows = Array.isArray(payload.holdings)
+    ? payload.holdings
+    : (Array.isArray(payload.positions) ? payload.positions : []);
+
+  if (rows.length === 0) {
+    throw new Error('Broker response does not include holdings/positions array');
+  }
+
+  const normalizedRows = rows.map(row => {
+    const normalized = {};
+    for (const [key, value] of Object.entries(row ?? {})) {
+      normalized[normalizeHeader(key)] = value;
+    }
+    return normalized;
+  });
+
+  const holdings = [];
+  const warnings = [];
+  for (let i = 0; i < normalizedRows.length; i += 1) {
+    const result = normalizeRow(normalizedRows[i], i, {
+      defaultCurrency: options.currency || payload.currency || DEFAULT_CURRENCY,
+    });
+    if (result.warning) warnings.push(result.warning);
+    if (result.holding) holdings.push(result.holding);
+  }
+
+  if (holdings.length === 0) {
+    throw new Error('Broker response has no valid holdings after normalization');
+  }
+
+  return {
+    source: options.source || 'broker_api',
+    source_name: options.sourceName || 'broker_snapshot',
+    source_risk: DEFAULT_SOURCE_RISK,
+    as_of: options.asOf || payload.as_of || new Date().toISOString(),
+    currency: options.currency || payload.currency || DEFAULT_CURRENCY,
+    holdings,
+    summary: summarizeHoldings(holdings),
+    warnings,
+  };
+}
+
+export function readCsvInput({ csvContent, csvBase64, filePath }) {
+  if (typeof csvContent === 'string' && csvContent.trim()) return csvContent;
+  if (typeof csvBase64 === 'string' && csvBase64.trim()) {
+    return Buffer.from(csvBase64, 'base64').toString('utf8');
+  }
+  if (typeof filePath === 'string' && filePath.trim()) {
+    return readFileSync(filePath, 'utf8');
+  }
+  throw new Error('Provide one of: csv_content, csv_base64, file_path');
+}

package/mcp-servers/portfolio-read/index.js

@@ -0,0 +1,127 @@
+#!/usr/bin/env node
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+import { extname } from 'path';
+
+import {
+  parsePortfolioCsv,
+  normalizePortfolioSnapshot,
+  readCsvInput,
+} from './core.js';
+
+const BROKER_BASE_URL = process.env.PORTFOLIO_BROKER_BASE_URL ?? '';
+const BROKER_TOKEN = process.env.PORTFOLIO_BROKER_TOKEN ?? '';
+const EXCEL_EXTENSIONS = new Set(['.xlsx', '.xls', '.xlsm', '.xlsb']);
+
+function toolError(message) {
+  return { isError: true, content: [{ type: 'text', text: `Error: ${message}` }] };
+}
+
+async function readPortfolioFromBroker({ broker_account_id, as_of, currency }) {
+  if (!BROKER_BASE_URL || !BROKER_TOKEN) {
+    throw new Error('broker credentials unavailable: ensure Secret Broker injects PORTFOLIO_BROKER_BASE_URL and PORTFOLIO_BROKER_TOKEN');
+  }
+
+  const url = new URL('/v1/portfolio/snapshot', BROKER_BASE_URL);
+  if (broker_account_id) url.searchParams.set('account_id', broker_account_id);
+
+  const res = await fetch(url, {
+    method: 'GET',
+    headers: {
+      'Authorization': `Bearer ${BROKER_TOKEN}`,
+      'Accept': 'application/json',
+    },
+  });
+
+  if (!res.ok) {
+    throw new Error(`broker request failed with status ${res.status}`);
+  }
+
+  const payload = await res.json();
+  return normalizePortfolioSnapshot(payload, {
+    source: 'broker_api',
+    sourceName: 'broker_snapshot',
+    asOf: as_of,
+    currency,
+  });
+}
+
+async function readTabularInput(input) {
+  const filePath = typeof input.file_path === 'string' ? input.file_path.trim() : '';
+  if (filePath && EXCEL_EXTENSIONS.has(extname(filePath).toLowerCase())) {
+    let xlsxModule;
+    try {
+      xlsxModule = await import('xlsx');
+    } catch {
+      throw new Error('Excel parsing requires the xlsx dependency. Install dependencies or convert the file to CSV.');
+    }
+
+    const xlsx = xlsxModule?.default ?? xlsxModule;
+    const workbook = xlsx.readFile(filePath, { cellDates: false });
+    const firstSheet = workbook.SheetNames?.[0];
+    if (!firstSheet) {
+      throw new Error('Excel file has no worksheet');
+    }
+
+    const csv = xlsx.utils.sheet_to_csv(workbook.Sheets[firstSheet], { blankrows: false });
+    if (!csv.trim()) {
+      throw new Error('Excel worksheet is empty');
+    }
+    return csv;
+  }
+
+  return readCsvInput({
+    csvContent: input.csv_content,
+    csvBase64: input.csv_base64,
+    filePath: input.file_path,
+  });
+}
+
+const server = new McpServer({ name: 'portfolio-read', version: '0.1.0' });
+
+server.tool(
+  'portfolio_read',
+  'Read user portfolio holdings. Supports CSV and Excel (xlsx/xls) input; broker API mode is available only with Secret Broker injected credentials.',
+  {
+    source_type: z.enum(['csv', 'broker']).optional().describe('Data source type. Default is csv.'),
+    csv_content: z.string().optional().describe('Raw CSV content.'),
+    csv_base64: z.string().optional().describe('Base64-encoded CSV content.'),
+    file_path: z.string().optional().describe('Absolute local file path of CSV or Excel (xlsx/xls) input.'),
+    delimiter: z.string().optional().describe('Optional delimiter override, e.g. "," or "\\t".'),
+    source_name: z.string().optional().describe('Logical source label for audit/reporting.'),
+    broker_account_id: z.string().optional().describe('Broker account identifier (required in broker mode when API needs it).'),
+    currency: z.string().optional().describe('Portfolio currency, default CNY.'),
+    as_of: z.string().optional().describe('As-of timestamp override (ISO8601 recommended).'),
+  },
+  async (input) => {
+    try {
+      const sourceType = input.source_type ?? 'csv';
+
+      const report = sourceType === 'broker'
+        ? await readPortfolioFromBroker(input)
+        : parsePortfolioCsv(
+            await readTabularInput(input),
+            {
+              delimiter: input.delimiter,
+              sourceName: input.source_name,
+              currency: input.currency,
+              asOf: input.as_of,
+            }
+          );
+
+      return {
+        content: [{
+          type: 'text',
+          text: JSON.stringify(report, null, 2),
+        }],
+      };
+    } catch (error) {
+      return toolError(error.message);
+    }
+  }
+);
+
+const transport = new StdioServerTransport();
+await server.connect(transport);
+console.error('[portfolio-read] MCP Server started');