@ian2018cs/agenthub 0.1.34 → 0.1.36

package/server/routes/skills.js

@@ -5,7 +5,7 @@ import { spawn } from 'child_process';
 import multer from 'multer';
 import AdmZip from 'adm-zip';
 import { getUserPaths, getPublicPaths, DATA_DIR } from '../services/user-directories.js';
-import { markBuiltinSkillRemoved, isBuiltinSkillPath } from '../services/builtin-skills.js';
+import { SYSTEM_REPO_OWNER, SYSTEM_REPO_NAME } from '../services/system-repo.js';
 
 const router = express.Router();
 
@@ -316,7 +316,16 @@ router.get('/', async (req, res) => {
         isSymlink = stat.isSymbolicLink();
 
         if (isSymlink) {
-          realPath = await fs.realpath(skillPath);
+          try {
+            realPath = await fs.realpath(skillPath);
+          } catch (realpathErr) {
+            if (realpathErr.code === 'ENOENT') {
+              // Dangling symlink - target no longer exists, remove it
+              await fs.unlink(skillPath).catch(() => {});
+              console.log(`[Skills] Removed dangling symlink: ${entry.name}`);
+            }
+            continue;
+          }
 
           // Determine source based on realPath
           if (realPath.includes('/skills-import/')) {
@@ -328,8 +337,6 @@ router.get('/', async (req, res) => {
             if (repoMatch) {
               repository = `${repoMatch[1]}/${repoMatch[2]}`;
             }
-          } else if (realPath.includes('/builtin-skills/')) {
-            source = 'builtin';
           }
         }
 
@@ -467,7 +474,6 @@ router.delete('/:name', async (req, res) => {
     let realPath = null;
     let isSymlink = false;
     let isImported = false;
-    let isBuiltin = false;
 
     try {
       const stat = await fs.lstat(linkPath);
@@ -475,7 +481,6 @@ router.delete('/:name', async (req, res) => {
       if (isSymlink) {
         realPath = await fs.realpath(linkPath);
         isImported = realPath.includes('/skills-import/');
-        isBuiltin = isBuiltinSkillPath(realPath);
       }
     } catch (err) {
       return res.status(404).json({ error: 'Skill not found' });
@@ -496,9 +501,6 @@ router.delete('/:name', async (req, res) => {
       } catch (err) {
         console.error('Error removing imported skill files:', err);
       }
-    } else if (isBuiltin) {
-      // Mark as removed so it won't be re-added on next sync
-      await markBuiltinSkillRemoved(userUuid, name);
     }
 
     res.json({ success: true, message: 'Skill deleted' });
@@ -793,13 +795,15 @@ router.get('/repos', async (req, res) => {
           // Count skills in repo (supports nested dirs like skills/XXX)
           const repoSkills = await scanDirForSkills(realPath, `${owner}/${repo}`, null);
           const skillCount = repoSkills.length;
+          const isSystem = owner === SYSTEM_REPO_OWNER && repo === SYSTEM_REPO_NAME;
 
           repos.push({
             owner,
             repo,
-            url: `https://github.com/${owner}/${repo}`,
+            url: isSystem ? null : `https://github.com/${owner}/${repo}`,
             skillCount,
-            path: realPath
+            path: realPath,
+            isSystem
           });
         }
       }
@@ -988,6 +992,11 @@ router.delete('/repos/:owner/:repo', async (req, res) => {
       return res.status(400).json({ error: 'Owner and repo are required' });
     }
 
+    // System repo cannot be removed
+    if (owner === SYSTEM_REPO_OWNER && repo === SYSTEM_REPO_NAME) {
+      return res.status(403).json({ error: '内置仓库不能删除' });
+    }
+
     const userPaths = getUserPaths(userUuid);
     const userRepoPath = path.join(userPaths.skillsRepoDir, owner, repo);
 

package/server/services/codex-mcp.js

@@ -0,0 +1,148 @@
+import { promises as fs } from 'fs';
+import TOML from '@iarna/toml';
+
+// ---------------------------------------------------------------------------
+// TOML formatting helpers — produce clean output with inline tables for env
+// ---------------------------------------------------------------------------
+
+function formatTomlValue(value) {
+  if (typeof value === 'string') return JSON.stringify(value);
+  if (typeof value === 'number' || typeof value === 'boolean') return String(value);
+  if (Array.isArray(value)) return '[' + value.map(formatTomlValue).join(', ') + ']';
+  if (value !== null && typeof value === 'object') {
+    const pairs = Object.entries(value).map(([k, v]) => `${k} = ${formatTomlValue(v)}`).join(', ');
+    return `{ ${pairs} }`;
+  }
+  return JSON.stringify(value);
+}
+
+// Fields that should always be written as inline tables even when they are objects
+const INLINE_TABLE_FIELDS = new Set(['env', 'http_headers', 'env_http_headers']);
+
+// Canonical field order for a mcp_servers entry
+const FIELD_ORDER = [
+  'command', 'url', 'args', 'env', 'env_vars', 'cwd',
+  'bearer_token_env_var', 'http_headers', 'env_http_headers',
+  'startup_timeout_sec', 'tool_timeout_sec', 'enabled', 'required',
+];
+
+function formatEntry(name, entry) {
+  const lines = [`[mcp_servers.${name}]`];
+  for (const key of FIELD_ORDER) {
+    if (entry[key] === undefined) continue;
+    const val = entry[key];
+    if (INLINE_TABLE_FIELDS.has(key) && val !== null && typeof val === 'object' && !Array.isArray(val)) {
+      const pairs = Object.entries(val).map(([k, v]) => `${k} = ${formatTomlValue(v)}`).join(', ');
+      lines.push(`${key} = { ${pairs} }`);
+    } else {
+      lines.push(`${key} = ${formatTomlValue(val)}`);
+    }
+  }
+  return lines.join('\n');
+}
+
+/**
+ * Format a mcp_servers map as a clean TOML block.
+ * Exported so that user-directories.js can append it to the base config template.
+ */
+export function formatMcpServersSection(mcpServers) {
+  return Object.entries(mcpServers)
+    .map(([name, entry]) => formatEntry(name, entry))
+    .join('\n\n');
+}
+
+// ---------------------------------------------------------------------------
+// Remove [mcp_servers.*] blocks from existing TOML text (text-based, safe)
+// ---------------------------------------------------------------------------
+
+function removeMcpServersFromContent(content) {
+  const lines = content.split('\n');
+  const result = [];
+  let inMcpServers = false;
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (/^\[mcp_servers[.\]]/.test(trimmed) || trimmed === '[mcp_servers]') {
+      inMcpServers = true;
+    } else if (inMcpServers && /^\[(?!mcp_servers)/.test(trimmed)) {
+      inMcpServers = false;
+    }
+    if (!inMcpServers) result.push(line);
+  }
+
+  return result.join('\n');
+}
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+/**
+ * Convert a Claude mcp.json server config entry to the equivalent Codex
+ * mcp_servers entry (drops the `type` discriminator, keeps compatible fields).
+ */
+export function mcpConfigToCodexEntry(serverConfig) {
+  const { type, command, args, env, cwd, url, ...rest } = serverConfig;
+  const entry = {};
+
+  if (type === 'stdio' || (!type && command)) {
+    if (command) entry.command = command;
+    if (args?.length) entry.args = args;
+    if (env && Object.keys(env).length > 0) entry.env = env;
+    if (cwd) entry.cwd = cwd;
+  } else if (type === 'http' || type === 'sse') {
+    if (url) entry.url = url;
+  }
+
+  for (const key of ['startup_timeout_sec', 'tool_timeout_sec', 'enabled', 'required', 'bearer_token_env_var']) {
+    if (rest[key] !== undefined) entry[key] = rest[key];
+  }
+
+  return entry;
+}
+
+/**
+ * Read the mcp_servers map from a Codex config.toml.
+ * Returns an empty object if the file doesn't exist or has no mcp_servers.
+ */
+export async function readCodexMcpServers(configPath) {
+  try {
+    const parsed = TOML.parse(await fs.readFile(configPath, 'utf-8'));
+    return parsed.mcp_servers || {};
+  } catch {
+    return {};
+  }
+}
+
+async function writeMcpServers(configPath, mcpServers) {
+  let existingContent = '';
+  try { existingContent = await fs.readFile(configPath, 'utf-8'); } catch { /* file missing */ }
+
+  let newContent = removeMcpServersFromContent(existingContent).trimEnd();
+  if (Object.keys(mcpServers).length > 0) {
+    newContent += '\n\n' + formatMcpServersSection(mcpServers);
+  }
+  await fs.writeFile(configPath, newContent + '\n', 'utf-8');
+}
+
+/**
+ * Add / update MCP servers in a Codex config.toml.
+ * mcpJson: the parsed contents of a mcp.json file ({ [serverName]: config }).
+ */
+export async function addToCodexConfig(configPath, mcpJson) {
+  const mcpServers = await readCodexMcpServers(configPath);
+  for (const [name, serverConfig] of Object.entries(mcpJson)) {
+    mcpServers[name] = mcpConfigToCodexEntry(serverConfig);
+  }
+  await writeMcpServers(configPath, mcpServers);
+}
+
+/**
+ * Remove a single MCP server from a Codex config.toml.
+ */
+export async function removeFromCodexConfig(configPath, serverName) {
+  const mcpServers = await readCodexMcpServers(configPath);
+  if (!(serverName in mcpServers)) return;
+  delete mcpServers[serverName];
+  await writeMcpServers(configPath, mcpServers);
+}

package/server/services/feishu/command-handler.js

@@ -84,7 +84,7 @@ export class CommandHandler {
   async _handleAuth(feishuOpenId, chatId, messageId, token) {
     if (!token) {
       await this._reply(chatId, messageId,
-        '请先完成账号绑定：\n\n1. 登录 Claude Code UI 网页\n2. 进入 **设置 → 账户**，点击「生成绑定 Token」\n3. 复制命令后在此发送：`/auth <token>`'
+        '请先完成账号绑定：\n\n1. 登录 AgentHub 网页：http://10.0.1.133:6175/\n2. 进入 **设置 → 账户**，点击「生成绑定 Token」\n3. 复制命令后在此发送：`/auth <token>`'
       );
       return true;
     }
@@ -295,7 +295,7 @@ export class CommandHandler {
       }
 
       if (projects.length === 0) {
-        await this._reply(chatId, messageId, '暂无项目，请在 Claude Code UI 中创建项目。');
+        await this._reply(chatId, messageId, '暂无项目，请在 AgentHub 中创建项目。');
         return true;
       }
 

package/server/services/feishu/feishu-engine.js

@@ -111,7 +111,7 @@ export class FeishuEngine {
       const binding = feishuDb.getBinding(feishuOpenId);
       if (!binding) {
         await this.larkClient.replyText(messageId,
-          '👋 你好！请先完成账号绑定：\n\n1. 登录 Claude Code UI 网页\n2. 进入 **设置 → 账户**，点击「生成绑定 Token」\n3. 复制命令后在此发送：`/auth <token>`'
+          '👋 你好！请先完成账号绑定：\n\n1. 登录 AgentHub 网页：http://10.0.1.133:6175/\n2. 进入 **设置 → 账户**，点击「生成绑定 Token」\n3. 复制命令后在此发送：`/auth <token>`'
         );
         return;
       }
@@ -221,7 +221,7 @@ export class FeishuEngine {
     const binding = feishuDb.getBinding(feishuOpenId);
     if (!binding && !commandText.toLowerCase().startsWith('/auth')) {
       await this.larkClient.sendTextToUser(feishuOpenId,
-        '👋 你好！请先完成账号绑定：\n\n1. 登录 Claude Code UI 网页\n2. 进入 **设置 → 账户**，点击「生成绑定 Token」\n3. 复制命令后在此发送：`/auth <token>`'
+        '👋 你好！请先完成账号绑定：\n\n1. 登录 AgentHub 网页：http://10.0.1.133:6175/\n2. 进入 **设置 → 账户**，点击「生成绑定 Token」\n3. 复制命令后在此发送：`/auth <token>`'
       );
       return;
     }

package/server/services/system-mcp-repo.js

@@ -0,0 +1,105 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+import { spawn } from 'child_process';
+import { getUserPaths, getPublicPaths } from './user-directories.js';
+
+const SYSTEM_MCP_REPO_URL = 'git@git.amberweather.com:mcp-server/hupoer-mcps.git';
+const SYSTEM_MCP_REPO_OWNER = 'mcp-server';
+const SYSTEM_MCP_REPO_NAME = 'hupoer-mcps';
+
+function cloneRepository(url, destinationPath) {
+  return new Promise((resolve, reject) => {
+    const gitProcess = spawn('git', ['clone', '--depth', '1', url, destinationPath], {
+      stdio: ['ignore', 'pipe', 'pipe'],
+      env: { ...process.env, GIT_TERMINAL_PROMPT: '0' }
+    });
+
+    let stderr = '';
+    gitProcess.stderr.on('data', (data) => { stderr += data.toString(); });
+    gitProcess.on('close', (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(stderr || `Git clone failed with code ${code}`));
+    });
+    gitProcess.on('error', (err) => { reject(err); });
+  });
+}
+
+function updateRepository(repoPath) {
+  return new Promise((resolve, reject) => {
+    const gitProcess = spawn('git', ['pull', '--ff-only'], {
+      cwd: repoPath,
+      stdio: ['ignore', 'pipe', 'pipe'],
+      env: { ...process.env, GIT_TERMINAL_PROMPT: '0' }
+    });
+
+    let stderr = '';
+    gitProcess.stderr.on('data', (data) => { stderr += data.toString(); });
+    gitProcess.on('close', (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(stderr || `Git pull failed with code ${code}`));
+    });
+    gitProcess.on('error', (err) => { reject(err); });
+  });
+}
+
+async function ensureSystemMcpRepo() {
+  const publicPaths = getPublicPaths();
+  const publicRepoPath = path.join(publicPaths.mcpRepoDir, SYSTEM_MCP_REPO_OWNER, SYSTEM_MCP_REPO_NAME);
+
+  try {
+    await fs.access(publicRepoPath);
+    // Already cloned — try to update
+    try {
+      await updateRepository(publicRepoPath);
+    } catch (err) {
+      console.log('[SystemMcpRepo] Failed to pull system MCP repo, using existing clone:', err.message);
+    }
+  } catch {
+    // Not yet cloned
+    await fs.mkdir(path.dirname(publicRepoPath), { recursive: true });
+    try {
+      await cloneRepository(SYSTEM_MCP_REPO_URL, publicRepoPath);
+      console.log('[SystemMcpRepo] Cloned system MCP repo to', publicRepoPath);
+    } catch (err) {
+      console.error('[SystemMcpRepo] Failed to clone system MCP repo:', err.message);
+      throw err;
+    }
+  }
+
+  return publicRepoPath;
+}
+
+/**
+ * Initialize the built-in MCP repo for a user.
+ * Idempotent: if the user already has the symlink, skip.
+ */
+export async function initSystemMcpRepoForUser(userUuid) {
+  const userPaths = getUserPaths(userUuid);
+  const userRepoPath = path.join(userPaths.mcpRepoDir, SYSTEM_MCP_REPO_OWNER, SYSTEM_MCP_REPO_NAME);
+
+  try {
+    await fs.lstat(userRepoPath);
+    // Already set up — nothing to do
+    return;
+  } catch {
+    // Doesn't exist — proceed with setup
+  }
+
+  let publicRepoPath;
+  try {
+    publicRepoPath = await ensureSystemMcpRepo();
+  } catch (err) {
+    console.error('[SystemMcpRepo] Could not ensure system MCP repo, skipping user init:', err.message);
+    return;
+  }
+
+  await fs.mkdir(path.dirname(userRepoPath), { recursive: true });
+  try {
+    await fs.symlink(publicRepoPath, userRepoPath);
+    console.log(`[SystemMcpRepo] Linked system MCP repo for user ${userUuid}`);
+  } catch (err) {
+    console.error(`[SystemMcpRepo] Failed to create symlink for user ${userUuid}:`, err.message);
+  }
+}
+
+export { SYSTEM_MCP_REPO_OWNER, SYSTEM_MCP_REPO_NAME, SYSTEM_MCP_REPO_URL };

package/server/services/system-repo.js

@@ -0,0 +1,116 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+import { spawn } from 'child_process';
+import { getUserPaths, getPublicPaths } from './user-directories.js';
+
+const SYSTEM_REPO_URL = 'git@git.amberweather.com:mcp-server/hupoer-skills.git';
+const SYSTEM_REPO_OWNER = 'mcp-server';
+const SYSTEM_REPO_NAME = 'hupoer-skills';
+
+function cloneRepository(url, destinationPath) {
+  return new Promise((resolve, reject) => {
+    const gitProcess = spawn('git', ['clone', '--depth', '1', url, destinationPath], {
+      stdio: ['ignore', 'pipe', 'pipe'],
+      env: { ...process.env, GIT_TERMINAL_PROMPT: '0' }
+    });
+
+    let stderr = '';
+    gitProcess.stderr.on('data', (data) => { stderr += data.toString(); });
+
+    gitProcess.on('close', (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(stderr || `Git clone failed with code ${code}`));
+    });
+
+    gitProcess.on('error', (err) => { reject(err); });
+  });
+}
+
+function updateRepository(repoPath) {
+  return new Promise((resolve, reject) => {
+    const gitProcess = spawn('git', ['pull', '--ff-only'], {
+      cwd: repoPath,
+      stdio: ['ignore', 'pipe', 'pipe'],
+      env: { ...process.env, GIT_TERMINAL_PROMPT: '0' }
+    });
+
+    let stderr = '';
+    gitProcess.stderr.on('data', (data) => { stderr += data.toString(); });
+
+    gitProcess.on('close', (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(stderr || `Git pull failed with code ${code}`));
+    });
+
+    gitProcess.on('error', (err) => { reject(err); });
+  });
+}
+
+/**
+ * Ensure the system repo is cloned to the shared public directory.
+ * If already cloned, attempts to pull latest changes.
+ * Returns the path to the public clone.
+ */
+async function ensureSystemRepo() {
+  const publicPaths = getPublicPaths();
+  const publicRepoPath = path.join(publicPaths.skillsRepoDir, SYSTEM_REPO_OWNER, SYSTEM_REPO_NAME);
+
+  try {
+    await fs.access(publicRepoPath);
+    // Already cloned — try to update
+    try {
+      await updateRepository(publicRepoPath);
+    } catch (err) {
+      console.log('[SystemRepo] Failed to pull system repo, using existing clone:', err.message);
+    }
+  } catch {
+    // Not yet cloned
+    await fs.mkdir(path.dirname(publicRepoPath), { recursive: true });
+    try {
+      await cloneRepository(SYSTEM_REPO_URL, publicRepoPath);
+      console.log('[SystemRepo] Cloned system repo to', publicRepoPath);
+    } catch (err) {
+      console.error('[SystemRepo] Failed to clone system repo:', err.message);
+      throw err;
+    }
+  }
+
+  return publicRepoPath;
+}
+
+/**
+ * Initialize the system repo for a user.
+ * Idempotent: if the user already has the symlink, skip.
+ */
+export async function initSystemRepoForUser(userUuid) {
+  const userPaths = getUserPaths(userUuid);
+  const userRepoPath = path.join(userPaths.skillsRepoDir, SYSTEM_REPO_OWNER, SYSTEM_REPO_NAME);
+
+  // If symlink/dir already exists, skip
+  try {
+    await fs.lstat(userRepoPath);
+    // Already set up — nothing to do
+    return;
+  } catch {
+    // Doesn't exist — proceed with setup
+  }
+
+  let publicRepoPath;
+  try {
+    publicRepoPath = await ensureSystemRepo();
+  } catch (err) {
+    console.error('[SystemRepo] Could not ensure system repo, skipping user init:', err.message);
+    return;
+  }
+
+  // Create user symlink
+  await fs.mkdir(path.dirname(userRepoPath), { recursive: true });
+  try {
+    await fs.symlink(publicRepoPath, userRepoPath);
+    console.log(`[SystemRepo] Linked system repo for user ${userUuid}`);
+  } catch (err) {
+    console.error(`[SystemRepo] Failed to create symlink for user ${userUuid}:`, err.message);
+  }
+}
+
+export { SYSTEM_REPO_OWNER, SYSTEM_REPO_NAME, SYSTEM_REPO_URL };

package/server/services/user-directories.js

@@ -1,6 +1,8 @@
 import { promises as fs } from 'fs';
 import path from 'path';
-import { initBuiltinSkills } from './builtin-skills.js';
+import { readCodexMcpServers, formatMcpServersSection } from './codex-mcp.js';
+import { initSystemRepoForUser } from './system-repo.js';
+import { initSystemMcpRepoForUser } from './system-mcp-repo.js';
 
 // Base data directory (configurable via env)
 const DATA_DIR = process.env.DATA_DIR || path.join(process.cwd(), 'data');
@@ -26,6 +28,7 @@ export function getUserPaths(userUuid) {
     skillsDir: path.join(DATA_DIR, 'user-data', userUuid, '.claude', 'skills'),
     skillsImportDir: path.join(DATA_DIR, 'user-data', userUuid, 'skills-import'),
     skillsRepoDir: path.join(DATA_DIR, 'user-data', userUuid, 'skills-repo'),
+    mcpRepoDir: path.join(DATA_DIR, 'user-data', userUuid, 'mcp-repo'),
     codexHomeDir: path.join(DATA_DIR, 'user-data', userUuid, 'codex-home'),
     geminiHomeDir: path.join(DATA_DIR, 'user-data', userUuid, 'gemini-home'),
   };
@@ -37,6 +40,7 @@ export function getUserPaths(userUuid) {
 export function getPublicPaths() {
   return {
     skillsRepoDir: path.join(DATA_DIR, 'skills-repo'),
+    mcpRepoDir: path.join(DATA_DIR, 'mcp-repo'),
   };
 }
 
@@ -52,9 +56,12 @@ export async function initCodexDirectories(userUuid) {
 
   await fs.mkdir(codexDir, { recursive: true });
 
-  // Write config.toml (overwrite to keep in sync with env)
+  // Write config.toml (overwrite to keep in sync with env, but preserve mcp_servers)
   const baseUrl = process.env.OPENAI_BASE_URL || '';
-  const configToml = `model_provider = "custom"
+  const configTomlPath = path.join(codexDir, 'config.toml');
+
+  const existingMcpServers = await readCodexMcpServers(configTomlPath);
+  let configToml = `model_provider = "custom"
 
 [model_providers.custom]
 name = "custom"
@@ -62,7 +69,10 @@ wire_api = "responses"
 requires_openai_auth = true
 base_url = "${baseUrl}"
 `;
-  await fs.writeFile(path.join(codexDir, 'config.toml'), configToml, 'utf8');
+  if (Object.keys(existingMcpServers).length > 0) {
+    configToml += '\n' + formatMcpServersSection(existingMcpServers) + '\n';
+  }
+  await fs.writeFile(configTomlPath, configToml, 'utf8');
 
   // Write auth.json only if it doesn't exist, to avoid overwriting user tokens
   const authJsonPath = path.join(codexDir, 'auth.json');
@@ -246,6 +256,12 @@ export async function initUserDirectories(userUuid) {
   await fs.mkdir(paths.skillsImportDir, { recursive: true });
   await fs.mkdir(paths.skillsRepoDir, { recursive: true });
 
+  // Create mcp-repo directory for the user
+  await fs.mkdir(paths.mcpRepoDir, { recursive: true });
+  // Ensure shared public mcp-repo directory exists
+  const publicPaths = getPublicPaths();
+  await fs.mkdir(publicPaths.mcpRepoDir, { recursive: true });
+
   // Initialize codex home directory with config files (after skillsDir exists for symlink)
   await initCodexDirectories(userUuid);
 
@@ -280,8 +296,11 @@ export async function initUserDirectories(userUuid) {
   await fs.writeFile(usageScanStatePath, JSON.stringify(scanState, null, 2));
   console.log(`Created .usage-scan-state.json for user ${userUuid}`);
 
-  // Initialize built-in skills
-  await initBuiltinSkills(userUuid);
+  // Initialize system repo (built-in skill repository)
+  await initSystemRepoForUser(userUuid);
+
+  // Initialize system MCP repo (built-in MCP repository)
+  await initSystemMcpRepoForUser(userUuid);
 
   return paths;
 }