@lightcone-ai/daemon 0.10.0 → 0.10.2

package/mcp-servers/platform/index.js

@@ -3,7 +3,7 @@ import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { z } from 'zod';
 
-const SERVER_URL      = process.env.PLATFORM_SERVER_URL ?? process.env.SERVER_URL ?? 'http://localhost:3001';
+const SERVER_URL      = process.env.PLATFORM_SERVER_URL ?? process.env.SERVER_URL ?? 'http://localhost:9779';
 const MACHINE_API_KEY = process.env.PLATFORM_MACHINE_API_KEY ?? process.env.MACHINE_API_KEY ?? '';
 const AGENT_ID        = process.env.PLATFORM_AGENT_ID ?? process.env.AGENT_ID ?? '';
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lightcone-ai/daemon",
-  "version": "0.10.0",
+  "version": "0.10.2",
   "type": "module",
   "main": "src/index.js",
   "bin": {
@@ -13,7 +13,9 @@
   ],
   "scripts": {
     "start": "node src/index.js",
-    "dev": "node --watch src/index.js"
+    "dev": "node --watch src/index.js",
+    "prepack": "node scripts/vendor-shared.js",
+    "postpack": "node scripts/unvendor-shared.js"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.12.0",

package/src/_vendor/mcp/registry.js

@@ -0,0 +1,327 @@
+import { existsSync, readdirSync, readFileSync, statSync } from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const MANIFEST_FILE = 'manifest.json';
+const ALLOWED_ROOT_RELATIVE_PATHS = Object.freeze([
+  'mcp-servers',
+  'daemon/mcp-servers',
+]);
+const VALID_TOOL_CLASSIFICATIONS = new Set(['mandatory', 'cacheable', 'local']);
+
+let cachedRegistry = null;
+
+function isPlainObject(value) {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+
+function isPathInside(parentDir, targetPath) {
+  const relative = path.relative(parentDir, targetPath);
+  return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
+}
+
+function normalizeServerId(value, fallback = '') {
+  const normalized = String(value ?? fallback).trim().toLowerCase();
+  if (!normalized) return '';
+  if (!/^[a-z0-9][a-z0-9_-]*$/.test(normalized)) return '';
+  return normalized;
+}
+
+function normalizeToolDeclarations(manifest, serverId) {
+  const declarations = [];
+
+  const direct = Array.isArray(manifest.tool_declarations)
+    ? manifest.tool_declarations
+    : Array.isArray(manifest.toolDeclarations)
+      ? manifest.toolDeclarations
+      : [];
+
+  for (const item of direct) {
+    if (typeof item === 'string') {
+      const name = String(item).trim();
+      if (!name) continue;
+      declarations.push({ name, classification: null });
+      continue;
+    }
+    if (!isPlainObject(item)) continue;
+    const name = String(item.name ?? item.tool ?? '').trim();
+    if (!name) continue;
+    const classification = String(item.classification ?? item.tool_classification ?? '').trim().toLowerCase();
+    declarations.push({
+      name,
+      classification: VALID_TOOL_CLASSIFICATIONS.has(classification) ? classification : null,
+    });
+  }
+
+  if (declarations.length > 0) {
+    return dedupeToolDeclarations(declarations);
+  }
+
+  const toolNames = Array.isArray(manifest.tool_names)
+    ? manifest.tool_names
+    : Array.isArray(manifest.toolNames)
+      ? manifest.toolNames
+      : [];
+  const declaredClassification = isPlainObject(manifest.tool_classification)
+    ? manifest.tool_classification
+    : isPlainObject(manifest.toolClassification)
+      ? manifest.toolClassification
+      : {};
+
+  for (const toolName of toolNames) {
+    const name = String(toolName ?? '').trim();
+    if (!name) continue;
+    const classification = String(declaredClassification[name] ?? '').trim().toLowerCase();
+    declarations.push({
+      name,
+      classification: VALID_TOOL_CLASSIFICATIONS.has(classification) ? classification : null,
+    });
+  }
+
+  if (declarations.length === 0 && serverId === 'chat') {
+    return [];
+  }
+
+  return dedupeToolDeclarations(declarations);
+}
+
+function dedupeToolDeclarations(declarations) {
+  const seen = new Set();
+  const output = [];
+  for (const declaration of declarations) {
+    const key = declaration.name;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    output.push(declaration);
+  }
+  return output;
+}
+
+function normalizeSmokeTest(manifest) {
+  const raw = manifest.smoke_test ?? manifest.smokeTest;
+  if (!isPlainObject(raw)) return null;
+  const tool = String(raw.tool ?? raw.tool_name ?? '').trim();
+  if (!tool) return null;
+  const args = isPlainObject(raw.arguments) ? raw.arguments : {};
+  return { tool, arguments: args };
+}
+
+function collectManifestFiles(rootDir, maxDepth = 4) {
+  const files = [];
+
+  function walk(currentDir, depth) {
+    if (depth > maxDepth) return;
+    let entries = [];
+    try {
+      entries = readdirSync(currentDir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+
+    for (const entry of entries) {
+      const fullPath = path.join(currentDir, entry.name);
+      if (entry.isDirectory()) {
+        walk(fullPath, depth + 1);
+        continue;
+      }
+      if (!entry.isFile() || entry.name !== MANIFEST_FILE) continue;
+      files.push(fullPath);
+    }
+  }
+
+  walk(rootDir, 0);
+  return files;
+}
+
+function resolveAllowedRoots(repoRoot) {
+  return ALLOWED_ROOT_RELATIVE_PATHS
+    .map((relativePath) => path.resolve(repoRoot, relativePath))
+    .filter((absolutePath) => existsSync(absolutePath));
+}
+
+function normalizeManifestEntry({
+  rawManifest,
+  manifestPath,
+  repoRoot,
+  allowedRoots,
+}) {
+  if (!isPlainObject(rawManifest)) {
+    throw new Error(`manifest root must be object: ${manifestPath}`);
+  }
+
+  const manifestDir = path.dirname(manifestPath);
+  const fallbackId = path.basename(manifestDir);
+  const id = normalizeServerId(rawManifest.id, fallbackId);
+  if (!id) {
+    throw new Error(`invalid server id in manifest: ${manifestPath}`);
+  }
+
+  const entrypointRaw = String(rawManifest.entrypoint ?? 'index.js').trim();
+  if (!entrypointRaw) {
+    throw new Error(`entrypoint is required: ${manifestPath}`);
+  }
+
+  const entrypointPath = path.resolve(manifestDir, entrypointRaw);
+  const insideAllowedBoundary = allowedRoots.some((root) => isPathInside(root, entrypointPath));
+  if (!insideAllowedBoundary) {
+    throw new Error(`entrypoint escapes allowed roots for '${id}': ${entrypointPath}`);
+  }
+
+  const entrypointExists = (() => {
+    try {
+      return statSync(entrypointPath).isFile();
+    } catch {
+      return false;
+    }
+  })();
+
+  const toolDeclarations = normalizeToolDeclarations(rawManifest, id);
+  const toolClassification = {};
+  for (const declaration of toolDeclarations) {
+    if (!declaration.classification) continue;
+    toolClassification[declaration.name] = declaration.classification;
+  }
+
+  return {
+    id,
+    name: String(rawManifest.name ?? id).trim() || id,
+    version: String(rawManifest.version ?? '0.0.0').trim() || '0.0.0',
+    manifestPath,
+    manifestDir,
+    entrypointPath,
+    entrypointExists,
+    runtime: String(rawManifest.runtime ?? 'node').trim() || 'node',
+    toolDeclarations,
+    toolClassification,
+    smokeTest: normalizeSmokeTest(rawManifest),
+    rawManifest,
+    repoRoot,
+  };
+}
+
+function buildRegistry({ repoRoot }) {
+  const normalizedRepoRoot = path.resolve(repoRoot);
+  const allowedRoots = resolveAllowedRoots(normalizedRepoRoot);
+  const manifestFiles = allowedRoots.flatMap((root) => collectManifestFiles(root));
+
+  const errors = [];
+  const servers = new Map();
+
+  for (const manifestPath of manifestFiles) {
+    let rawManifest = null;
+    try {
+      rawManifest = JSON.parse(readFileSync(manifestPath, 'utf8'));
+    } catch (error) {
+      errors.push({
+        manifestPath,
+        code: 'manifest_parse_failed',
+        message: error.message,
+      });
+      continue;
+    }
+
+    let entry;
+    try {
+      entry = normalizeManifestEntry({
+        rawManifest,
+        manifestPath,
+        repoRoot: normalizedRepoRoot,
+        allowedRoots,
+      });
+    } catch (error) {
+      errors.push({
+        manifestPath,
+        code: 'manifest_invalid',
+        message: error.message,
+      });
+      continue;
+    }
+
+    if (servers.has(entry.id)) {
+      const previous = servers.get(entry.id);
+      errors.push({
+        manifestPath,
+        code: 'duplicate_server_id',
+        message: `duplicate server id '${entry.id}' (${previous.manifestPath} vs ${entry.manifestPath})`,
+      });
+      continue;
+    }
+
+    servers.set(entry.id, entry);
+  }
+
+  return {
+    repoRoot: normalizedRepoRoot,
+    allowedRoots,
+    manifestFiles,
+    servers,
+    errors,
+    loadedAt: new Date().toISOString(),
+  };
+}
+
+function defaultRepoRoot() {
+  const currentFile = fileURLToPath(import.meta.url);
+  return path.resolve(path.dirname(currentFile), '..', '..');
+}
+
+export function loadMcpServerRegistry({
+  repoRoot = defaultRepoRoot(),
+  refresh = false,
+  strict = false,
+} = {}) {
+  const normalizedRepoRoot = path.resolve(repoRoot);
+
+  if (!refresh && cachedRegistry && cachedRegistry.repoRoot === normalizedRepoRoot) {
+    if (strict && cachedRegistry.errors.length > 0) {
+      throw new Error(`mcp manifest registry has ${cachedRegistry.errors.length} error(s)`);
+    }
+    return cachedRegistry;
+  }
+
+  const registry = buildRegistry({ repoRoot: normalizedRepoRoot });
+  cachedRegistry = registry;
+
+  if (strict && registry.errors.length > 0) {
+    throw new Error(`mcp manifest registry has ${registry.errors.length} error(s)`);
+  }
+  return registry;
+}
+
+export function getMcpServerManifest(serverId, options = {}) {
+  const id = normalizeServerId(serverId);
+  if (!id) return null;
+  const registry = loadMcpServerRegistry(options);
+  return registry.servers.get(id) ?? null;
+}
+
+export function resolveMcpServerEntrypoint(serverId, options = {}) {
+  const entry = getMcpServerManifest(serverId, options);
+  if (!entry) return null;
+  return entry.entrypointPath;
+}
+
+export function getMcpToolClassificationMap(options = {}) {
+  const registry = loadMcpServerRegistry(options);
+  const classification = {};
+
+  for (const server of registry.servers.values()) {
+    for (const [toolName, toolClass] of Object.entries(server.toolClassification)) {
+      if (!VALID_TOOL_CLASSIFICATIONS.has(toolClass)) continue;
+      classification[toolName] = toolClass;
+    }
+  }
+
+  return classification;
+}
+
+export function getMcpRegistryDiagnostics(options = {}) {
+  const registry = loadMcpServerRegistry(options);
+  return {
+    repoRoot: registry.repoRoot,
+    loadedAt: registry.loadedAt,
+    manifestCount: registry.manifestFiles.length,
+    serverCount: registry.servers.size,
+    errors: registry.errors,
+  };
+}

package/src/agent-manager.js

@@ -1,7 +1,16 @@
 import { spawn } from 'child_process';
-import { mkdirSync, writeFileSync, readdirSync, unlinkSync } from 'fs';
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  statSync,
+  unlinkSync,
+  writeFileSync,
+} from 'fs';
 import { homedir } from 'os';
 import path from 'path';
+import { fileURLToPath } from 'url';
 import { parseCodexLine, adaptCodexSystemPrompt } from './drivers/codex.js';
 import { parseKimiLine, encodeKimiStdin } from './drivers/kimi.js';
 import { startSession, stopSession, stopAllSessions } from './browser-login.js';
@@ -10,6 +19,95 @@ import { markInvalidatedLeases } from './governance-state.js';
 const KIMI_SYSTEM_PROMPT_FILE = '.lightcone-kimi-system.md';
 const KIMI_AGENT_FILE = '.lightcone-kimi-agent.yaml';
 const KIMI_MCP_FILE = '.lightcone-kimi-mcp.json';
+const LOCAL_FILE_DIR = path.dirname(fileURLToPath(import.meta.url));
+const LOCAL_MCP_ROOTS = Object.freeze([
+  path.resolve(LOCAL_FILE_DIR, '../mcp-servers'),
+  path.resolve(LOCAL_FILE_DIR, '../../mcp-servers'),
+]);
+
+function isPlainObject(value) {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+
+function normalizeMcpServerId(value, fallback = '') {
+  const normalized = String(value ?? fallback).trim().toLowerCase();
+  if (!normalized) return '';
+  if (!/^[a-z0-9][a-z0-9_-]*$/.test(normalized)) return '';
+  return normalized;
+}
+
+function isFile(filePath) {
+  try {
+    return statSync(filePath).isFile();
+  } catch {
+    return false;
+  }
+}
+
+function collectMcpPathsFromRoot(rootDir, output) {
+  if (!existsSync(rootDir)) return;
+
+  const pending = [rootDir];
+  const visited = new Set();
+  const fallbackCandidates = new Map();
+
+  while (pending.length > 0) {
+    const currentDir = pending.pop();
+    if (visited.has(currentDir)) continue;
+    visited.add(currentDir);
+
+    const manifestPath = path.join(currentDir, 'manifest.json');
+    if (isFile(manifestPath)) {
+      try {
+        const manifest = JSON.parse(readFileSync(manifestPath, 'utf8'));
+        const serverId = normalizeMcpServerId(manifest?.id, path.basename(currentDir));
+        const entrypointRaw = String(manifest?.entrypoint ?? 'index.js').trim() || 'index.js';
+        const entrypointPath = path.resolve(currentDir, entrypointRaw);
+        if (serverId && isFile(entrypointPath) && !Object.hasOwn(output, serverId)) {
+          output[serverId] = entrypointPath;
+        }
+      } catch {
+        // Ignore malformed manifest and keep scanning sibling directories.
+      }
+    } else {
+      const fallbackId = normalizeMcpServerId(path.basename(currentDir));
+      const fallbackEntrypoint = path.join(currentDir, 'index.js');
+      if (
+        currentDir !== rootDir
+        && fallbackId
+        && isFile(fallbackEntrypoint)
+        && !Object.hasOwn(output, fallbackId)
+        && !fallbackCandidates.has(fallbackId)
+      ) {
+        fallbackCandidates.set(fallbackId, fallbackEntrypoint);
+      }
+    }
+
+    let entries = [];
+    try {
+      entries = readdirSync(currentDir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      pending.push(path.join(currentDir, entry.name));
+    }
+  }
+
+  for (const [serverId, entrypointPath] of fallbackCandidates.entries()) {
+    if (Object.hasOwn(output, serverId)) continue;
+    output[serverId] = entrypointPath;
+  }
+}
+
+function collectLocalMcpPaths() {
+  const output = {};
+  for (const rootDir of LOCAL_MCP_ROOTS) {
+    collectMcpPathsFromRoot(rootDir, output);
+  }
+  return output;
+}
 
 function runtimeMissingDetail(runtime) {
   return `cli_missing:${runtime}`;
@@ -25,7 +123,7 @@ function resolveExitOfflineDetail({ code, signal, stopCause }) {
 }
 
 function normalizeObject(value) {
-  return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+  return isPlainObject(value) ? value : {};
 }
 
 function replacePlaceholders(text, replacements) {
@@ -434,6 +532,7 @@ export class AgentManager {
           session_id: config?.sessionId ?? null,
           workspace_dir: workspaceDir,
           chat_bridge_path: chatBridgePath,
+          mcp_paths: collectLocalMcpPaths(),
         },
         agent_profile: {
           name: config?.name ?? null,

package/src/chat-bridge.js

@@ -14,7 +14,7 @@ function getArg(name) {
   return idx !== -1 && cliArgs[idx + 1] ? cliArgs[idx + 1] : '';
 }
 
-const SERVER_URL      = process.env.SERVER_URL || getArg('--server-url') || 'http://localhost:8777';
+const SERVER_URL      = process.env.SERVER_URL || getArg('--server-url') || 'http://localhost:9779';
 const MACHINE_API_KEY = process.env.MACHINE_API_KEY || getArg('--auth-token') || '';
 const AGENT_ID        = process.env.AGENT_ID || getArg('--agent-id') || '';
 const WORKSPACE_ID      = process.env.WORKSPACE_ID || getArg('--workspace-id') || '';  // injected per-workspace at spawn time

package/src/drivers/claude.js

@@ -169,9 +169,9 @@ When referencing a workspace or mentioning someone, write them as plain text wit
 
 When writing a URL next to non-ASCII punctuation (Chinese, Japanese, etc.), always wrap the URL in angle brackets or use markdown link syntax. Otherwise the punctuation may be rendered as part of the URL.
 
-- **Wrong**: \`测试环境：http://localhost:3000，请查看\` (the \`，\` gets swallowed into the link)
-- **Correct**: \`测试环境：<http://localhost:3000>，请查看\`
-- **Also correct**: \`测试环境：[http://localhost:3000](http://localhost:3000)，请查看\`
+- **Wrong**: \`测试环境：http://localhost:9779，请查看\` (the \`，\` gets swallowed into the link)
+- **Correct**: \`测试环境：<http://localhost:9779>，请查看\`
+- **Also correct**: \`测试环境：[http://localhost:9779](http://localhost:9779)，请查看\`
 
 ## Filesystem Access
 

package/src/index.js

@@ -39,7 +39,7 @@ if (opts['--help'] || opts['-h']) {
   process.exit(0);
 }
 
-const SERVER_URL = String(opts['--server-url'] || process.env.SERVER_URL || 'http://localhost:8779').trim();
+const SERVER_URL = String(opts['--server-url'] || process.env.SERVER_URL || 'http://localhost:9779').trim();
 const MACHINE_API_KEY = String(opts['--api-key'] || process.env.MACHINE_API_KEY || '').trim();
 
 if (!MACHINE_API_KEY) {

package/src/mcp-config.js

@@ -1,5 +1,5 @@
 import { profileDir } from './browser-login.js';
-import { resolveMcpServerEntrypoint } from '../../src/mcp/registry.js';
+import { resolveMcpServerEntrypoint } from './_vendor/mcp/registry.js';
 
 const LEGACY_MCP_PATH_TOKENS = Object.freeze({
   '{mysql_mcp_path}': 'mysql',
@@ -16,7 +16,7 @@ const LEGACY_MCP_PATH_TOKENS = Object.freeze({
   '{portfolio_analysis_mcp_path}': 'portfolio-analysis',
 });
 
-function resolveMcpPathToken(arg) {
+function resolveMcpPathToken(arg, mcpPaths = {}) {
   if (typeof arg !== 'string') return null;
 
   const trimmed = arg.trim();
@@ -27,6 +27,13 @@ function resolveMcpPathToken(arg) {
   const serverId = legacyId ?? (dynamicMatch ? dynamicMatch[1].toLowerCase() : null);
   if (!serverId) return null;
 
+  const runtimeMcpPath = typeof mcpPaths?.[serverId] === 'string'
+    ? mcpPaths[serverId].trim()
+    : '';
+  if (runtimeMcpPath) {
+    return runtimeMcpPath;
+  }
+
   const entrypointPath = resolveMcpServerEntrypoint(serverId, { strict: true });
   if (!entrypointPath) {
     throw new Error(`MCP server '${serverId}' is not registered in manifest registry`);
@@ -35,7 +42,7 @@ function resolveMcpPathToken(arg) {
 }
 
 function resolveSkillArg(arg, config) {
-  const resolvedMcpPath = resolveMcpPathToken(arg);
+  const resolvedMcpPath = resolveMcpPathToken(arg, config?.mcpPaths);
   if (resolvedMcpPath) return resolvedMcpPath;
   if (arg === '{xhs_profile_dir}')
     return profileDir('xhs', config.userId ?? 'default');