@lightcone-ai/daemon 0.9.79 → 0.10.1

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

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

package/mcp-servers/publisher/index.js

@@ -23,9 +23,9 @@ import { withProfileLock } from '../../src/profile-lock.js';
 const SERVER_URL      = process.env.SERVER_URL ?? '';
 const MACHINE_API_KEY = process.env.MACHINE_API_KEY ?? '';
 const AGENT_ID        = process.env.AGENT_ID ?? '';
-const TEAM_ID         = process.env.TEAM_ID ?? '';
+const WORKSPACE_ID         = process.env.WORKSPACE_ID ?? '';
 const WORKSPACE_DIR   = process.env.WORKSPACE_DIR ?? process.cwd();
-const TEAM_WORKSPACE_DIR = path.dirname(WORKSPACE_DIR);
+const WORKSPACE_ROOT_DIR = path.dirname(WORKSPACE_DIR);
 
 // ── Platform registry ──────────────────────────────────────────────────────────
 
@@ -87,7 +87,7 @@ async function api(method, path, body) {
   });
   if (!res.ok) {
     const text = await res.text();
-    throw new Error(`Lightcone API ${method} ${path} failed (${res.status}): ${text}`);
+    throw new Error(`lightcone API ${method} ${path} failed (${res.status}): ${text}`);
   }
   return res.json();
 }
@@ -139,15 +139,15 @@ function workspacePathFromMediaPath(filePath, approvalData) {
 
   const normalized = filePath.replaceAll('\\', '/');
   const virtualMatch = normalized.match(/^\/agent-workspace\/([^/]+)\/workspace\/(.+)$/);
-  if (virtualMatch) return { teamId: virtualMatch[1], relPath: virtualMatch[2] };
+  if (virtualMatch) return { workspaceId: virtualMatch[1], relPath: virtualMatch[2] };
 
   const workspaceSegmentMatch = normalized.match(/\/workspace\/((?:artifacts|notes|tmp)\/.+)$/);
   if (workspaceSegmentMatch) {
-    return { teamId: approvalData?.teamId ?? TEAM_ID, relPath: workspaceSegmentMatch[1] };
+    return { workspaceId: approvalData?.workspaceId ?? WORKSPACE_ID, relPath: workspaceSegmentMatch[1] };
   }
 
   if (!path.isAbsolute(filePath) && /^(artifacts|notes|tmp)\//.test(normalized)) {
-    return { teamId: approvalData?.teamId ?? TEAM_ID, relPath: normalized };
+    return { workspaceId: approvalData?.workspaceId ?? WORKSPACE_ID, relPath: normalized };
   }
 
   return null;
@@ -157,23 +157,23 @@ async function materializeWorkspaceMedia(filePath, approvalData) {
   if (!filePath || existsSync(filePath)) return filePath;
 
   const workspacePath = workspacePathFromMediaPath(filePath, approvalData);
-  if (!workspacePath?.teamId || !workspacePath.relPath) return filePath;
+  if (!workspacePath?.workspaceId || !workspacePath.relPath) return filePath;
 
-  const localPath = path.resolve(TEAM_WORKSPACE_DIR, workspacePath.relPath);
-  const allowedRoots = ['artifacts', 'notes', 'tmp'].map(dir => path.join(TEAM_WORKSPACE_DIR, dir));
+  const localPath = path.resolve(WORKSPACE_ROOT_DIR, workspacePath.relPath);
+  const allowedRoots = ['artifacts', 'notes', 'tmp'].map(dir => path.join(WORKSPACE_ROOT_DIR, dir));
   if (!allowedRoots.some(root => isInsideDir(localPath, root))) {
-    throw new Error(`workspace media path is outside allowed team workspace directories: ${filePath}`);
+    throw new Error(`workspace media path is outside allowed workspace directories: ${filePath}`);
   }
 
   if (existsSync(localPath)) return localPath;
 
   const data = await api(
     'GET',
-    `/team-memory?path=${encodeURIComponent(workspacePath.relPath)}&teamId=${encodeURIComponent(workspacePath.teamId)}`
+    `/workspace-memory?path=${encodeURIComponent(workspacePath.relPath)}&workspaceId=${encodeURIComponent(workspacePath.workspaceId)}`
   );
   mkdirSync(path.dirname(localPath), { recursive: true });
   writeFileSync(localPath, decodeWorkspaceContent(data.content));
-  console.error(`[publisher] Materialized team workspace media ${workspacePath.relPath} -> ${localPath}`);
+  console.error(`[publisher] Materialized workspace media ${workspacePath.relPath} -> ${localPath}`);
   return localPath;
 }
 
@@ -201,12 +201,12 @@ function validateLocalFile(filePath, { kind, required = false, allowedExts = []
   const allowedRoots = [
     realpathSync(WORKSPACE_DIR),
     ...['artifacts', 'notes', 'tmp']
-      .map(dir => path.join(TEAM_WORKSPACE_DIR, dir))
+      .map(dir => path.join(WORKSPACE_ROOT_DIR, dir))
       .filter(existsSync)
       .map(dir => realpathSync(dir)),
   ];
   if (!allowedRoots.some(root => isInsideDir(realFile, root))) {
-    throw new Error(`${kind} file must be inside the agent workspace or team shared artifacts/notes/tmp directory: ${filePath}`);
+    throw new Error(`${kind} file must be inside the agent workspace or workspace shared artifacts/notes/tmp directory: ${filePath}`);
   }
 
   const stat = statSync(realFile);

package/mcp-servers/publisher/manifest.json

@@ -0,0 +1,16 @@
+{
+  "id": "publisher",
+  "name": "Publisher MCP Server",
+  "version": "0.1.0",
+  "runtime": "node",
+  "entrypoint": "index.js",
+  "tool_declarations": [
+    { "name": "get_platform_requirements", "classification": "cacheable" },
+    { "name": "check_login_status", "classification": "mandatory" },
+    { "name": "publish_content", "classification": "mandatory" }
+  ],
+  "smoke_test": {
+    "tool": "get_platform_requirements",
+    "arguments": { "platform": "xhs", "content_type": "image_text" }
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lightcone-ai/daemon",
-  "version": "0.9.79",
+  "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,
+  };
+}