@lightcone-ai/daemon 0.10.0 → 0.10.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lightcone-ai/daemon",
-  "version": "0.10.0",
+  "version": "0.10.1",
   "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/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',