@lightcone-ai/daemon 0.6.6 → 0.6.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lightcone-ai/daemon",
-  "version": "0.6.6",
+  "version": "0.6.8",
   "type": "module",
   "main": "src/index.js",
   "bin": {

package/src/agent-manager.js

@@ -1,5 +1,5 @@
 import { spawn } from 'child_process';
-import { mkdirSync, readdirSync, readFileSync, statSync, lstatSync } from 'fs';
+import { mkdirSync, statSync } from 'fs';
 import { homedir } from 'os';
 import path from 'path';
 import { buildSystemPrompt } from './drivers/claude.js';
@@ -25,7 +25,6 @@ export class AgentManager {
       case 'agent:start':       return this._startAgent(msg, connection);
       case 'agent:stop':        return this._stopAgent(msg.agentId, msg.channelId, connection);
       case 'agent:deliver':     return this._deliverMessage(msg, connection);
-      case 'agent:skills:list': return this._listSkills(msg, connection);
       case 'ping':              return connection.send({ type: 'pong' });
       default:
         console.log(`[AgentManager] Unhandled: ${msg.type}`);
@@ -62,7 +61,7 @@ export class AgentManager {
     return msg;
   }
 
-  _startAgent({ agentId, channelId, config }, connection) {
+  async _startAgent({ agentId, channelId, config }, connection) {
     const key = this._key(agentId, channelId);
     if (this.agents.has(key) || this.starting.has(key)) {
       console.log(`[AgentManager] Agent ${agentId} in channel ${channelId} already registered`);
@@ -75,13 +74,25 @@ export class AgentManager {
     const chatBridgePath = new URL('./chat-bridge.js', import.meta.url).pathname;
     const startupMsg = runtime === 'codex' ? this._takePendingMessage(key) : null;
 
+    // Fetch skills index for system prompt + MCP derivation (non-blocking on failure)
+    let skills = [];
+    try {
+      const chParam = channelId ? `?channelId=${encodeURIComponent(channelId)}` : '';
+      const res = await fetch(`${this.serverUrl}/internal/agent/${agentId}/skills${chParam}`, {
+        headers: { 'Authorization': `Bearer ${this.machineApiKey}` },
+      });
+      if (res.ok) skills = await res.json();
+    } catch (err) {
+      console.log(`[AgentManager] Skills fetch failed for ${agentId} (non-fatal): ${err.message}`);
+    }
+
     let proc;
 
     if (runtime === 'kimi') {
       // ── Kimi CLI ──────────────────────────────────────────────────────────
       const kimiSpawn = buildKimiSpawn({
         config, agentId, channelId, workspaceDir, chatBridgePath,
-        serverUrl: this.serverUrl, machineApiKey: this.machineApiKey,
+        serverUrl: this.serverUrl, machineApiKey: this.machineApiKey, skills,
       });
 
       console.log(`[AgentManager] Spawning kimi for ${agentId} channel=${channelId ?? 'none'} (session=${kimiSpawn.sessionId})`);
@@ -131,6 +142,7 @@ export class AgentManager {
         serverUrl: this.serverUrl,
         machineApiKey: this.machineApiKey,
         prompt: startupPrompt,
+        skills,
       });
 
       console.log(`[AgentManager] Spawning codex for ${agentId} channel=${channelId ?? 'none'} (session=${config.sessionId ?? 'new'})`);
@@ -172,27 +184,25 @@ export class AgentManager {
         },
       };
 
-      if (config.browserAccess) {
-        mcpServers['chrome-devtools'] = {
-          command: 'npx',
-          args: ['chrome-devtools-mcp@latest', '--headless'],
-          env: {},
-        };
-      }
-
-      if (config.mysqlAccess) {
-        const mysqlServerPath = new URL('../../mcp-servers/mysql/index.js', import.meta.url).pathname;
-        const agentEnv = config.envVars ?? {};
-        mcpServers['mysql'] = {
-          command: 'node',
-          args: [mysqlServerPath],
-          env: {
-            DB_HOST:     process.env.DB_HOST      ?? '',
-            DB_PORT:     process.env.DB_PORT      ?? '3306',
-            DB_USER:     process.env.DB_USER      ?? '',
-            DB_PASSWORD: process.env.DB_PASSWORD  ?? '',
-            DB_NAME:     agentEnv.MYSQL_DB ?? process.env.DB_NAME ?? '',
-          },
+      // Derive MCP servers from skills with mcp_config
+      const agentEnv = config.envVars ?? {};
+      for (const skill of skills) {
+        if (!skill.mcpConfig) continue;
+        const mc = skill.mcpConfig;
+        if (mcpServers[mc.server]) continue; // already added
+        const resolvedArgs = (mc.args ?? []).map(a =>
+          a === '{mysql_mcp_path}'
+            ? new URL('../../mcp-servers/mysql/index.js', import.meta.url).pathname
+            : a
+        );
+        const resolvedEnv = {};
+        for (const envKey of (mc.env ?? [])) {
+          resolvedEnv[envKey] = agentEnv[envKey] ?? process.env[envKey] ?? '';
+        }
+        mcpServers[mc.server] = {
+          command: mc.command,
+          args: resolvedArgs,
+          env: resolvedEnv,
         };
       }
 
@@ -206,7 +216,7 @@ export class AgentManager {
         '--output-format', 'stream-json',
         '--input-format', 'stream-json',
         '--mcp-config', JSON.stringify(mcpConfig),
-        '--system-prompt', buildSystemPrompt(config, agentId),
+        '--system-prompt', buildSystemPrompt(config, agentId, skills),
         '--disallowed-tools', 'EnterPlanMode,ExitPlanMode',
       ];
 
@@ -383,99 +393,6 @@ export class AgentManager {
     }
   }
 
-  // ── skills ────────────────────────────────────────────────────────────────
-
-  _listSkills({ agentId, channelId, requestId }, connection) {
-    const home = homedir();
-    // Find workspace dir for this agent (check running agents first, else derive)
-    const key = this._key(agentId, channelId);
-    const agent = this.agents.get(key);
-    const workspaceDir = agent
-      ? this._workspaceDir(agentId, agent.channelId)
-      : this._workspaceDir(agentId, channelId);
-
-    const runtime = agent?.config?.runtime ?? 'claude';
-    const skillDirs = runtime === 'codex'
-      ? {
-          global: [
-            path.join(home, '.codex', 'skills'),
-            path.join(home, '.codex', 'skills', '.system'),
-            path.join(home, '.agents', 'skills'),
-          ],
-          workspace: [
-            path.join(workspaceDir, '.codex', 'skills'),
-            path.join(workspaceDir, '.agents', 'skills'),
-          ],
-        }
-      : {
-          global: [
-            path.join(home, '.claude', 'skills'),
-            path.join(home, '.claude', 'commands'),
-          ],
-          workspace: [
-            path.join(workspaceDir, '.claude', 'skills'),
-            path.join(workspaceDir, '.claude', 'commands'),
-          ],
-        };
-
-    const dedup = (skills) => {
-      const seen = new Set();
-      return skills.filter(s => {
-        if (seen.has(s.name)) return false;
-        seen.add(s.name);
-        return true;
-      });
-    };
-    const shorten = (skills) => skills.map(s => ({
-      ...s,
-      sourcePath: s.sourcePath?.startsWith(home) ? '~' + s.sourcePath.slice(home.length) : s.sourcePath,
-    }));
-
-    const global = shorten(dedup(skillDirs.global.flatMap(d => this._scanSkillsDir(d))));
-    const workspace = shorten(dedup(skillDirs.workspace.flatMap(d => this._scanSkillsDir(d))));
-
-    connection.send({ type: 'agent:skills:list_result', agentId, requestId, global, workspace });
-  }
-
-  _scanSkillsDir(dir) {
-    let entries;
-    try { entries = readdirSync(dir, { withFileTypes: true }); }
-    catch { return []; }
-    const skills = [];
-    for (const entry of entries) {
-      if (entry.isDirectory() || entry.isSymbolicLink()) {
-        const skillMd = path.join(dir, entry.name, 'SKILL.md');
-        try {
-          const content = readFileSync(skillMd, 'utf-8');
-          skills.push({ ...this._parseSkillMd(entry.name, content), sourcePath: dir });
-        } catch {}
-      } else if (entry.name.endsWith('.md')) {
-        const cmdName = entry.name.replace(/\.md$/, '');
-        try {
-          const content = readFileSync(path.join(dir, entry.name), 'utf-8');
-          skills.push({ ...this._parseSkillMd(cmdName, content), sourcePath: dir });
-        } catch {}
-      }
-    }
-    return skills;
-  }
-
-  _parseSkillMd(dirName, content) {
-    const info = { name: dirName, displayName: dirName, description: '', userInvocable: false };
-    const match = content.match(/^---\n([\s\S]*?)\n---/);
-    if (!match) return info;
-    for (const line of match[1].split('\n')) {
-      const idx = line.indexOf(':');
-      if (idx === -1) continue;
-      const key = line.slice(0, idx).trim();
-      const value = line.slice(idx + 1).trim();
-      if (key === 'name') info.displayName = value;
-      if (key === 'description') info.description = value;
-      if (key === 'user-invocable') info.userInvocable = value === 'true';
-    }
-    return info;
-  }
-
   _parseKimiLine(key, agentId, channelId, line, connection) {
     const agent = this.agents.get(key);
     if (!agent) return;

package/src/chat-bridge.js

@@ -260,6 +260,66 @@ server.tool('write_memory', 'Write or update a memory file (full content replace
   return { content: [{ type: 'text', text: `Saved ${path}` }] };
 });
 
+// ── skill_list ───────────────────────────────────────────────────────────────
+server.tool('skill_list', 'List all skills available to you (platform + bound). Returns index only (name + description), not full content.', {}, async () => {
+  const chParam = currentChannelId ? `?channelId=${encodeURIComponent(currentChannelId)}` : '';
+  const skills = await api('GET', `/skills${chParam}`);
+  if (!skills || skills.length === 0) return { content: [{ type: 'text', text: 'No skills available.' }] };
+  const lines = skills.map(s => `- [${s.type}] **${s.name}** — ${s.description}`);
+  return { content: [{ type: 'text', text: lines.join('\n') }] };
+});
+
+// ── skill_read ───────────────────────────────────────────────────────────────
+server.tool('skill_read', 'Read the full content of a skill by name or ID', {
+  name: z.string().describe('Skill name or ID'),
+}, async ({ name }) => {
+  try {
+    const skill = await api('GET', `/skills/${encodeURIComponent(name)}`);
+    return { content: [{ type: 'text', text: `# ${skill.name}\n\n${skill.content}` }] };
+  } catch (err) {
+    if (err.message.includes('404')) return { content: [{ type: 'text', text: `Skill "${name}" not found.` }] };
+    throw err;
+  }
+});
+
+// ── skill_create ─────────────────────────────────────────────────────────────
+server.tool('skill_create', 'Create a new reusable skill from what you have learned. Auto-binds to the current channel.', {
+  name:        z.string().describe('Short skill name (lowercase, hyphens ok), e.g. "xhs-posting"'),
+  description: z.string().describe('One-line description of what this skill covers'),
+  content:     z.string().describe('Full skill content in markdown — procedures, steps, tips'),
+  tags:        z.array(z.string()).optional().describe('Optional tags for categorization'),
+}, async ({ name, description, content, tags }) => {
+  const body = { name, description, content, tags: tags ?? [] };
+  if (currentChannelId) body.channelId = currentChannelId;
+  const result = await api('POST', '/skills', body);
+  return { content: [{ type: 'text', text: `Skill "${result.name}" created and bound to current channel.` }] };
+});
+
+// ── skill_update ─────────────────────────────────────────────────────────────
+server.tool('skill_update', 'Update an existing skill content, description, or tags', {
+  name:        z.string().describe('Skill name or ID to update'),
+  content:     z.string().optional().describe('New full content (replaces existing)'),
+  description: z.string().optional().describe('New description'),
+  tags:        z.array(z.string()).optional().describe('New tags'),
+}, async ({ name, content, description, tags }) => {
+  const body = {};
+  if (content != null) body.content = content;
+  if (description != null) body.description = description;
+  if (tags != null) body.tags = tags;
+  const result = await api('PATCH', `/skills/${encodeURIComponent(name)}`, body);
+  return { content: [{ type: 'text', text: `Skill "${result.name}" updated.` }] };
+});
+
+// ── skill_search ─────────────────────────────────────────────────────────────
+server.tool('skill_search', 'Search for skills by keyword across all accessible skills', {
+  query: z.string().describe('Search keyword'),
+}, async ({ query }) => {
+  const skills = await api('GET', `/skills/search?q=${encodeURIComponent(query)}`);
+  if (!skills || skills.length === 0) return { content: [{ type: 'text', text: `No skills found for "${query}".` }] };
+  const lines = skills.map(s => `- [${s.type}] **${s.name}** — ${s.description}`);
+  return { content: [{ type: 'text', text: lines.join('\n') }] };
+});
+
 // ── read_file_base64 ──────────────────────────────────────────────────────────
 // Agent 需要在本机读取图片文件内容，转为 base64 后上传服务器
 server.tool('read_file_base64',

package/src/drivers/claude.js

@@ -515,7 +515,44 @@ const PUBLISHER_PROMPT = `
 
 // ── 主函数 ────────────────────────────────────────────────────────────────────
 
-export function buildSystemPrompt(config, agentId) {
+function buildSkillsPrompt(skills) {
+  if (!skills || skills.length === 0) return '';
+
+  const platform = skills.filter(s => s.type === 'platform');
+  const user = skills.filter(s => s.type === 'user');
+
+  let section = `
+
+## Skills — Reusable Knowledge & Procedures
+
+You have access to reusable skills — proven procedures for common tasks.
+Skills are loaded progressively: the index below shows what's available.
+Use \`skill_read\` to load full content when needed.
+
+### How to use skills
+
+- Before starting unfamiliar work, search for relevant skills: \`skill_search({ query: "..." })\`
+- Load a skill's full procedure: \`skill_read({ name: "skill-name" })\`
+- After completing a complex task (5+ tool calls), consider saving it as a skill: \`skill_create({ name, description, content })\`
+- When using a skill and finding it outdated or wrong, update it immediately: \`skill_update({ name, content })\`
+- Skills you create are automatically shared with other agents in the same channel
+
+### Available Skills
+`;
+
+  if (platform.length > 0) {
+    section += `\n**Platform Skills:**\n`;
+    for (const s of platform) section += `- **${s.name}** — ${s.description}\n`;
+  }
+  if (user.length > 0) {
+    section += `\n**Bound Skills:**\n`;
+    for (const s of user) section += `- **${s.name}** — ${s.description}\n`;
+  }
+
+  return section;
+}
+
+export function buildSystemPrompt(config, agentId, skills) {
   const { name, displayName, description, feishuBotName } = config;
 
   const base = BASE_PROMPT(displayName, name, description, agentId, feishuBotName);
@@ -527,5 +564,7 @@ export function buildSystemPrompt(config, agentId) {
     'publisher':    PUBLISHER_PROMPT,
   }[name] ?? '';
 
-  return base + rolePrompt;
+  const skillsPrompt = buildSkillsPrompt(skills);
+
+  return base + skillsPrompt + rolePrompt;
 }

package/src/drivers/codex.js

@@ -18,6 +18,15 @@ function quote(value) {
   return JSON.stringify(value);
 }
 
+function normalizeCodexModel(model) {
+  if (!model) return 'gpt-5.2';
+  const normalized = String(model).trim().toLowerCase();
+  if (!normalized) return 'gpt-5.2';
+  if (['sonnet', 'opus', 'haiku'].includes(normalized)) return 'gpt-5.2';
+  if (normalized.startsWith('claude-')) return 'gpt-5.2';
+  return model;
+}
+
 function ensureGitRepo(workspaceDir) {
   const gitDir = path.join(workspaceDir, '.git');
   if (existsSync(gitDir)) return;
@@ -53,7 +62,7 @@ export function buildCodexSystemPrompt(config, agentId) {
 }
 
 export function buildCodexSpawn({
-  config, agentId, channelId, workspaceDir, chatBridgePath, serverUrl, machineApiKey, prompt,
+  config, agentId, channelId, workspaceDir, chatBridgePath, serverUrl, machineApiKey, prompt, skills,
 }) {
   ensureGitRepo(workspaceDir);
 
@@ -80,34 +89,36 @@ export function buildCodexSpawn({
     '-c', 'mcp_servers.chat.tool_timeout_sec=300',
   );
 
-  if (config.browserAccess) {
-    args.push(
-      '-c', `mcp_servers.chrome-devtools.command=${quote('npx')}`,
-      '-c', `mcp_servers.chrome-devtools.args=${quote(['chrome-devtools-mcp@latest', '--headless'])}`,
-      '-c', 'mcp_servers.chrome-devtools.enabled=true'
-    );
-  }
-
-  if (config.mysqlAccess) {
-    const mysqlServerPath = new URL('../../mcp-servers/mysql/index.js', import.meta.url).pathname;
-    const agentEnv = config.envVars ?? {};
-    args.push(
-      '-c', `mcp_servers.mysql.command=${quote('env')}`,
-      '-c', `mcp_servers.mysql.args=${quote([
-        `DB_HOST=${process.env.DB_HOST ?? ''}`,
-        `DB_PORT=${process.env.DB_PORT ?? '3306'}`,
-        `DB_USER=${process.env.DB_USER ?? ''}`,
-        `DB_PASSWORD=${process.env.DB_PASSWORD ?? ''}`,
-        `DB_NAME=${agentEnv.MYSQL_DB ?? process.env.DB_NAME ?? ''}`,
-        'node',
-        mysqlServerPath,
-      ])}`,
-      '-c', 'mcp_servers.mysql.enabled=true'
+  // Derive MCP servers from skills with mcpConfig
+  const agentEnv = config.envVars ?? {};
+  for (const skill of (skills ?? [])) {
+    if (!skill.mcpConfig) continue;
+    const mc = skill.mcpConfig;
+    const resolvedArgs = (mc.args ?? []).map(a =>
+      a === '{mysql_mcp_path}'
+        ? new URL('../../mcp-servers/mysql/index.js', import.meta.url).pathname
+        : a
     );
+    // For codex, MCP servers use env wrapper for env vars
+    const envPairs = (mc.env ?? []).map(k => `${k}=${agentEnv[k] ?? process.env[k] ?? ''}`);
+    if (envPairs.length > 0) {
+      args.push(
+        '-c', `mcp_servers.${quote(mc.server)}.command=${quote('env')}`,
+        '-c', `mcp_servers.${quote(mc.server)}.args=${quote([...envPairs, mc.command, ...resolvedArgs])}`,
+        '-c', `mcp_servers.${quote(mc.server)}.enabled=true`
+      );
+    } else {
+      args.push(
+        '-c', `mcp_servers.${quote(mc.server)}.command=${quote(mc.command)}`,
+        '-c', `mcp_servers.${quote(mc.server)}.args=${quote(resolvedArgs)}`,
+        '-c', `mcp_servers.${quote(mc.server)}.enabled=true`
+      );
+    }
   }
 
-  if (config.model) {
-    args.push('-m', config.model);
+  const model = normalizeCodexModel(config.model);
+  if (model) {
+    args.push('-m', model);
   }
 
   if (config.reasoningEffort) {

package/src/drivers/kimi.js

@@ -12,7 +12,7 @@ const KIMI_MCP_FILE = '.lightcone-kimi-mcp.json';
  * Build Kimi CLI spawn args and config files.
  * Returns { args, env, setupFiles() } ready for spawn('kimi', args, { env }).
  */
-export function buildKimiSpawn({ config, agentId, channelId, workspaceDir, chatBridgePath, serverUrl, machineApiKey }) {
+export function buildKimiSpawn({ config, agentId, channelId, workspaceDir, chatBridgePath, serverUrl, machineApiKey, skills }) {
   const isResume = !!config.sessionId;
   const sessionId = config.sessionId || randomUUID();
 
@@ -51,29 +51,22 @@ export function buildKimiSpawn({ config, agentId, channelId, workspaceDir, chatB
     },
   };
 
-  if (config.browserAccess) {
-    mcpServers['chrome-devtools'] = {
-      command: 'npx',
-      args: ['chrome-devtools-mcp@latest', '--headless'],
-      env: {},
-    };
-  }
-
-  if (config.mysqlAccess) {
-    // Use relative path — caller provides the absolute path
-    const mysqlServerPath = new URL('../../mcp-servers/mysql/index.js', import.meta.url).pathname;
-    const agentEnv = config.envVars ?? {};
-    mcpServers['mysql'] = {
-      command: 'node',
-      args: [mysqlServerPath],
-      env: {
-        DB_HOST:     process.env.DB_HOST      ?? '',
-        DB_PORT:     process.env.DB_PORT      ?? '3306',
-        DB_USER:     process.env.DB_USER      ?? '',
-        DB_PASSWORD: process.env.DB_PASSWORD  ?? '',
-        DB_NAME:     agentEnv.MYSQL_DB ?? process.env.DB_NAME ?? '',
-      },
-    };
+  // Derive MCP servers from skills with mcpConfig
+  const agentEnv = config.envVars ?? {};
+  for (const skill of (skills ?? [])) {
+    if (!skill.mcpConfig) continue;
+    const mc = skill.mcpConfig;
+    if (mcpServers[mc.server]) continue;
+    const resolvedArgs = (mc.args ?? []).map(a =>
+      a === '{mysql_mcp_path}'
+        ? new URL('../../mcp-servers/mysql/index.js', import.meta.url).pathname
+        : a
+    );
+    const resolvedEnv = {};
+    for (const envKey of (mc.env ?? [])) {
+      resolvedEnv[envKey] = agentEnv[envKey] ?? process.env[envKey] ?? '';
+    }
+    mcpServers[mc.server] = { command: mc.command, args: resolvedArgs, env: resolvedEnv };
   }
 
   writeFileSync(mcpConfigPath, JSON.stringify({ mcpServers }), 'utf8');