@ian2018cs/agenthub 0.1.35 → 0.1.37

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/user-directories.js

@@ -1,6 +1,8 @@
 import { promises as fs } from 'fs';
 import path from 'path';
+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);
 
@@ -283,6 +299,9 @@ export async function initUserDirectories(userUuid) {
   // Initialize system repo (built-in skill repository)
   await initSystemRepoForUser(userUuid);
 
+  // Initialize system MCP repo (built-in MCP repository)
+  await initSystemMcpRepoForUser(userUuid);
+
   return paths;
 }