@lightcone-ai/daemon 0.9.79 → 0.10.1

package/mcp-servers/mysql/index.js

@@ -4,12 +4,20 @@ import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import { z } from 'zod';
 import mysql from 'mysql2/promise';
 
+function requiredEnv(name) {
+  const value = process.env[name];
+  if (!value) {
+    throw new Error(`${name} is required; configure the remote Tencent MySQL connection in .env`);
+  }
+  return value;
+}
+
 const pool = mysql.createPool({
-  host:     process.env.DB_HOST     ?? 'localhost',
-  port:     Number(process.env.DB_PORT ?? 3306),
-  user:     process.env.DB_USER     ?? 'root',
-  password: process.env.DB_PASSWORD ?? '',
-  database: process.env.DB_NAME     ?? 'snowland',
+  host:     requiredEnv('DB_HOST'),
+  port:     Number(requiredEnv('DB_PORT')),
+  user:     requiredEnv('DB_USER'),
+  password: requiredEnv('DB_PASSWORD'),
+  database: requiredEnv('DB_NAME'),
   waitForConnections: true,
   connectionLimit: 3,
 });

package/mcp-servers/mysql/manifest.json

@@ -0,0 +1,16 @@
+{
+  "id": "mysql",
+  "name": "MySQL MCP Server",
+  "version": "0.1.0",
+  "runtime": "node",
+  "entrypoint": "index.js",
+  "tool_declarations": [
+    { "name": "search_jobs", "classification": "cacheable" },
+    { "name": "get_job_detail", "classification": "cacheable" },
+    { "name": "list_jobs", "classification": "cacheable" }
+  ],
+  "smoke_test": {
+    "tool": "list_jobs",
+    "arguments": { "limit": 1 }
+  }
+}

package/mcp-servers/official/company-fundamentals/index.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+import { z } from 'zod';
+import { FUNDAMENTAL_FIXTURES, fixtureResponse, normalizeTicker } from '../../official-common/fixtures.js';
+import { startFixtureServer } from '../../official-common/server.js';
+
+await startFixtureServer({
+  serverId: 'company-fundamentals',
+  serverName: 'official-company-fundamentals',
+  toolName: 'company_fundamentals',
+  toolDescription: 'Return fixture-mode company fundamentals with explicit source metadata.',
+  inputSchema: {
+    ticker: z.string().describe('Ticker symbol, e.g. 600519.SH or AAPL.US.'),
+  },
+  handler: ({ ticker }) => {
+    const normalizedTicker = normalizeTicker(ticker);
+    const fundamentals = FUNDAMENTAL_FIXTURES[normalizedTicker] ?? null;
+
+    if (!fundamentals) {
+      return fixtureResponse({
+        capability: 'company-fundamentals',
+        ticker: normalizedTicker,
+        found: false,
+        message: 'Ticker not found in fixture dataset.',
+      });
+    }
+
+    return fixtureResponse({
+      capability: 'company-fundamentals',
+      ticker: normalizedTicker,
+      found: true,
+      fundamentals,
+    });
+  },
+});

package/mcp-servers/official/company-fundamentals/manifest.json

@@ -0,0 +1,14 @@
+{
+  "id": "company-fundamentals",
+  "name": "Official Company Fundamentals MCP",
+  "version": "0.1.0",
+  "runtime": "node",
+  "entrypoint": "index.js",
+  "tool_declarations": [
+    { "name": "company_fundamentals", "classification": "cacheable" }
+  ],
+  "smoke_test": {
+    "tool": "company_fundamentals",
+    "arguments": { "ticker": "AAPL.US" }
+  }
+}

package/mcp-servers/official/compliance-check/index.js

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+import { z } from 'zod';
+import { COMPLIANCE_RULES, fixtureResponse } from '../../official-common/fixtures.js';
+import { startFixtureServer } from '../../official-common/server.js';
+
+const FORBIDDEN_PATTERNS = [
+  /(买入|卖出|加仓|清仓).*(股|手|%)/u,
+  /(保本|稳赚|必赚|无风险)/u,
+  /(内幕|未公开信息|小道消息)/u,
+];
+
+await startFixtureServer({
+  serverId: 'compliance-check',
+  serverName: 'official-compliance-check',
+  toolName: 'compliance_check',
+  toolDescription: 'Run fixture-mode compliance checks for finance conversation outputs.',
+  inputSchema: {
+    statement: z.string().describe('Statement to be checked for compliance risks.'),
+  },
+  handler: ({ statement }) => {
+    const text = String(statement ?? '').trim();
+    const violations = [];
+
+    if (!text) {
+      violations.push({
+        rule_id: 'empty_statement',
+        level: 'warn',
+        message: 'Input statement is empty; no compliance conclusion can be made.',
+      });
+    }
+
+    for (const pattern of FORBIDDEN_PATTERNS) {
+      if (!pattern.test(text)) continue;
+      violations.push({
+        rule_id: 'high_risk_pattern_detected',
+        level: 'blocker',
+        message: `Matched forbidden pattern: ${pattern}`,
+      });
+    }
+
+    return fixtureResponse({
+      capability: 'compliance-check',
+      compliant: violations.length === 0,
+      violations,
+      ruleset: COMPLIANCE_RULES,
+      checked_text_preview: text.slice(0, 280),
+    });
+  },
+});

package/mcp-servers/official/compliance-check/manifest.json

@@ -0,0 +1,14 @@
+{
+  "id": "compliance-check",
+  "name": "Official Compliance Check MCP",
+  "version": "0.1.0",
+  "runtime": "node",
+  "entrypoint": "index.js",
+  "tool_declarations": [
+    { "name": "compliance_check", "classification": "mandatory" }
+  ],
+  "smoke_test": {
+    "tool": "compliance_check",
+    "arguments": { "statement": "请直接给我买入 100 股的建议" }
+  }
+}

package/mcp-servers/official/industry-report/index.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+import { z } from 'zod';
+import { INDUSTRY_FIXTURES, fixtureResponse } from '../../official-common/fixtures.js';
+import { startFixtureServer } from '../../official-common/server.js';
+
+await startFixtureServer({
+  serverId: 'industry-report',
+  serverName: 'official-industry-report',
+  toolName: 'industry_report',
+  toolDescription: 'Return fixture-mode industry outlook reports and key metrics.',
+  inputSchema: {
+    industry: z.string().describe('Industry key, e.g. semiconductors or baijiu.'),
+  },
+  handler: ({ industry }) => {
+    const normalizedIndustry = String(industry ?? '').trim().toLowerCase();
+    const report = INDUSTRY_FIXTURES[normalizedIndustry] ?? null;
+
+    if (!report) {
+      return fixtureResponse({
+        capability: 'industry-report',
+        industry: normalizedIndustry,
+        found: false,
+        available_industries: Object.keys(INDUSTRY_FIXTURES),
+      });
+    }
+
+    return fixtureResponse({
+      capability: 'industry-report',
+      industry: normalizedIndustry,
+      found: true,
+      report,
+    });
+  },
+});

package/mcp-servers/official/industry-report/manifest.json

@@ -0,0 +1,14 @@
+{
+  "id": "industry-report",
+  "name": "Official Industry Report MCP",
+  "version": "0.1.0",
+  "runtime": "node",
+  "entrypoint": "index.js",
+  "tool_declarations": [
+    { "name": "industry_report", "classification": "cacheable" }
+  ],
+  "smoke_test": {
+    "tool": "industry_report",
+    "arguments": { "industry": "semiconductors" }
+  }
+}

package/mcp-servers/official/market-data-query/index.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+import { z } from 'zod';
+import { MARKET_DATA_FIXTURES, fixtureResponse, normalizeTicker } from '../../official-common/fixtures.js';
+import { startFixtureServer } from '../../official-common/server.js';
+
+await startFixtureServer({
+  serverId: 'market-data-query',
+  serverName: 'official-market-data-query',
+  toolName: 'market_data_query',
+  toolDescription: 'Return fixture-mode market snapshot data with citation metadata.',
+  inputSchema: {
+    ticker: z.string().describe('Ticker symbol, e.g. 600519.SH or NVDA.US.'),
+  },
+  handler: ({ ticker }) => {
+    const normalizedTicker = normalizeTicker(ticker);
+    const snapshot = MARKET_DATA_FIXTURES[normalizedTicker] ?? null;
+
+    if (!snapshot) {
+      return fixtureResponse({
+        capability: 'market-data-query',
+        ticker: normalizedTicker,
+        found: false,
+        message: 'Ticker not found in fixture dataset.',
+      });
+    }
+
+    return fixtureResponse({
+      capability: 'market-data-query',
+      ticker: normalizedTicker,
+      found: true,
+      snapshot,
+    });
+  },
+});

package/mcp-servers/official/market-data-query/manifest.json

@@ -0,0 +1,14 @@
+{
+  "id": "market-data-query",
+  "name": "Official Market Data Query MCP",
+  "version": "0.1.0",
+  "runtime": "node",
+  "entrypoint": "index.js",
+  "tool_declarations": [
+    { "name": "market_data_query", "classification": "cacheable" }
+  ],
+  "smoke_test": {
+    "tool": "market_data_query",
+    "arguments": { "ticker": "NVDA.US" }
+  }
+}

package/mcp-servers/official/portfolio-analysis/index.js

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+import { z } from 'zod';
+import { PORTFOLIO_FIXTURES, fixtureResponse } from '../../official-common/fixtures.js';
+import { startFixtureServer } from '../../official-common/server.js';
+
+function normalizeHoldings(rawHoldings) {
+  if (!Array.isArray(rawHoldings) || rawHoldings.length === 0) {
+    return PORTFOLIO_FIXTURES.default.holdings;
+  }
+  return rawHoldings
+    .filter(item => item && typeof item === 'object')
+    .map(item => ({
+      ticker: String(item.ticker ?? '').trim(),
+      market_value: Number(item.market_value ?? item.marketValue ?? 0),
+      sector: String(item.sector ?? 'unknown').trim() || 'unknown',
+    }))
+    .filter(item => item.ticker && Number.isFinite(item.market_value) && item.market_value > 0);
+}
+
+function buildSectorExposure(holdings, totalValue) {
+  const bySector = new Map();
+  for (const holding of holdings) {
+    const previous = bySector.get(holding.sector) ?? 0;
+    bySector.set(holding.sector, previous + holding.market_value);
+  }
+
+  return [...bySector.entries()]
+    .map(([sector, value]) => ({
+      sector,
+      market_value: Number(value.toFixed(2)),
+      weight_pct: totalValue > 0 ? Number(((value / totalValue) * 100).toFixed(2)) : 0,
+    }))
+    .sort((a, b) => b.market_value - a.market_value);
+}
+
+await startFixtureServer({
+  serverId: 'portfolio-analysis',
+  serverName: 'official-portfolio-analysis',
+  toolName: 'portfolio_analysis',
+  toolDescription: 'Run fixture-mode portfolio concentration and sector exposure analysis.',
+  inputSchema: {
+    holdings: z.array(z.object({
+      ticker: z.string(),
+      market_value: z.number().optional(),
+      marketValue: z.number().optional(),
+      sector: z.string().optional(),
+    })).optional().describe('Optional holdings array; uses default fixture portfolio when omitted.'),
+  },
+  handler: ({ holdings }) => {
+    const normalizedHoldings = normalizeHoldings(holdings);
+
+    const totalValue = normalizedHoldings.reduce((acc, item) => acc + item.market_value, 0);
+    const sortedByValue = [...normalizedHoldings].sort((a, b) => b.market_value - a.market_value);
+    const top = sortedByValue[0] ?? null;
+    const topWeightPct = top && totalValue > 0
+      ? Number(((top.market_value / totalValue) * 100).toFixed(2))
+      : 0;
+
+    return fixtureResponse({
+      capability: 'portfolio-analysis',
+      holdings_count: normalizedHoldings.length,
+      total_market_value: Number(totalValue.toFixed(2)),
+      concentration: {
+        top_holding_ticker: top?.ticker ?? null,
+        top_holding_weight_pct: topWeightPct,
+      },
+      sector_exposure: buildSectorExposure(normalizedHoldings, totalValue),
+      citation: {
+        id: 'fixture://portfolio/analysis-2026-04-20',
+        source: 'Local fixture portfolio analytics engine',
+      },
+    });
+  },
+});

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

@@ -0,0 +1,14 @@
+{
+  "id": "portfolio-analysis",
+  "name": "Official Portfolio Analysis MCP",
+  "version": "0.1.0",
+  "runtime": "node",
+  "entrypoint": "index.js",
+  "tool_declarations": [
+    { "name": "portfolio_analysis", "classification": "mandatory" }
+  ],
+  "smoke_test": {
+    "tool": "portfolio_analysis",
+    "arguments": {}
+  }
+}

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

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+import { z } from 'zod';
+import { PORTFOLIO_FIXTURES, fixtureResponse } from '../../official-common/fixtures.js';
+import { startFixtureServer } from '../../official-common/server.js';
+
+await startFixtureServer({
+  serverId: 'portfolio-read',
+  serverName: 'official-portfolio-read',
+  toolName: 'portfolio_read',
+  toolDescription: 'Read fixture-mode portfolio snapshots with explicit source metadata.',
+  inputSchema: {
+    profile: z.string().optional().describe('Portfolio profile key (default: default).'),
+  },
+  handler: ({ profile = 'default' }) => {
+    const profileKey = String(profile ?? 'default').trim().toLowerCase() || 'default';
+    const snapshot = PORTFOLIO_FIXTURES[profileKey] ?? null;
+
+    if (!snapshot) {
+      return fixtureResponse({
+        capability: 'portfolio-read',
+        profile: profileKey,
+        found: false,
+        available_profiles: Object.keys(PORTFOLIO_FIXTURES),
+      });
+    }
+
+    return fixtureResponse({
+      capability: 'portfolio-read',
+      profile: profileKey,
+      found: true,
+      snapshot,
+    });
+  },
+});

package/mcp-servers/official/portfolio-read/manifest.json

@@ -0,0 +1,14 @@
+{
+  "id": "portfolio-read",
+  "name": "Official Portfolio Read MCP",
+  "version": "0.1.0",
+  "runtime": "node",
+  "entrypoint": "index.js",
+  "tool_declarations": [
+    { "name": "portfolio_read", "classification": "mandatory" }
+  ],
+  "smoke_test": {
+    "tool": "portfolio_read",
+    "arguments": { "profile": "default" }
+  }
+}

package/mcp-servers/official/research-fetch/index.js

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+import { z } from 'zod';
+import { RESEARCH_FIXTURES, fixtureResponse, normalizeTicker } from '../../official-common/fixtures.js';
+import { startFixtureServer } from '../../official-common/server.js';
+
+await startFixtureServer({
+  serverId: 'research-fetch',
+  serverName: 'official-research-fetch',
+  toolName: 'research_fetch',
+  toolDescription: 'Fetch fixture-mode research notes with explicit citations (non-real-time).',
+  inputSchema: {
+    query: z.string().optional().describe('Keyword query for report filtering.'),
+    ticker: z.string().optional().describe('Ticker symbol, e.g. 600519.SH or NVDA.US.'),
+    limit: z.number().int().min(1).max(10).optional().describe('Maximum returned notes (default 3).'),
+  },
+  handler: ({ query, ticker, limit = 3 }) => {
+    const normalizedQuery = String(query ?? '').trim().toLowerCase();
+    const normalizedTicker = normalizeTicker(ticker);
+
+    const matches = RESEARCH_FIXTURES.filter((item) => {
+      if (normalizedTicker && item.ticker !== normalizedTicker) return false;
+      if (!normalizedQuery) return true;
+      const haystack = `${item.title} ${item.summary}`.toLowerCase();
+      return haystack.includes(normalizedQuery);
+    }).slice(0, limit);
+
+    return fixtureResponse({
+      capability: 'research-fetch',
+      query: normalizedQuery || null,
+      ticker: normalizedTicker || null,
+      count: matches.length,
+      notes: matches,
+    });
+  },
+});

package/mcp-servers/official/research-fetch/manifest.json

@@ -0,0 +1,14 @@
+{
+  "id": "research-fetch",
+  "name": "Official Research Fetch MCP",
+  "version": "0.1.0",
+  "runtime": "node",
+  "entrypoint": "index.js",
+  "tool_declarations": [
+    { "name": "research_fetch", "classification": "cacheable" }
+  ],
+  "smoke_test": {
+    "tool": "research_fetch",
+    "arguments": { "query": "demand", "limit": 1 }
+  }
+}

package/mcp-servers/official/risk-metrics/index.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+import { z } from 'zod';
+import { RISK_FIXTURES, fixtureResponse, normalizeTicker } from '../../official-common/fixtures.js';
+import { startFixtureServer } from '../../official-common/server.js';
+
+await startFixtureServer({
+  serverId: 'risk-metrics',
+  serverName: 'official-risk-metrics',
+  toolName: 'risk_metrics',
+  toolDescription: 'Return fixture-mode risk metrics (beta, VaR, drawdown) with citation.',
+  inputSchema: {
+    ticker: z.string().describe('Ticker symbol, e.g. NVDA.US.'),
+  },
+  handler: ({ ticker }) => {
+    const normalizedTicker = normalizeTicker(ticker);
+    const metrics = RISK_FIXTURES[normalizedTicker] ?? null;
+
+    if (!metrics) {
+      return fixtureResponse({
+        capability: 'risk-metrics',
+        ticker: normalizedTicker,
+        found: false,
+        message: 'Ticker not found in fixture dataset.',
+      });
+    }
+
+    return fixtureResponse({
+      capability: 'risk-metrics',
+      ticker: normalizedTicker,
+      found: true,
+      metrics,
+    });
+  },
+});

package/mcp-servers/official/risk-metrics/manifest.json

@@ -0,0 +1,14 @@
+{
+  "id": "risk-metrics",
+  "name": "Official Risk Metrics MCP",
+  "version": "0.1.0",
+  "runtime": "node",
+  "entrypoint": "index.js",
+  "tool_declarations": [
+    { "name": "risk_metrics", "classification": "cacheable" }
+  ],
+  "smoke_test": {
+    "tool": "risk_metrics",
+    "arguments": { "ticker": "600519.SH" }
+  }
+}