@ian2018cs/agenthub 0.2.4 → 0.2.6

package/server/routes/skill-suite.js

@@ -0,0 +1,347 @@
+import express from 'express';
+import { promises as fs } from 'fs';
+import path from 'path';
+import { spawn, exec } from 'child_process';
+import { getUserPaths, getPublicPaths } from '../services/user-directories.js';
+
+const router = express.Router();
+
+// ─── lark-cli 套装常量 ──────────────────────────────────────────────────────
+
+const LARK_CLI_SKILLS = [
+  'lark-base', 'lark-calendar', 'lark-contact', 'lark-doc', 'lark-drive',
+  'lark-event', 'lark-im', 'lark-mail', 'lark-minutes', 'lark-openapi-explorer',
+  'lark-shared', 'lark-sheets', 'lark-skill-maker', 'lark-task', 'lark-vc',
+  'lark-whiteboard', 'lark-wiki', 'lark-workflow-meeting-summary',
+  'lark-workflow-standup-report',
+];
+
+const LARK_CLI_REPO_URL = 'https://github.com/larksuite/cli';
+const LARK_CLI_REPO_OWNER = 'larksuite';
+const LARK_CLI_REPO_NAME = 'cli';
+
+// ─── 认证策略表（便于未来扩展其他套装） ────────────────────────────────────
+
+const AUTH_STRATEGIES = {
+  feishu: {
+    getEnv: (larkCliDir) => ({ LARKSUITE_CLI_CONFIG_DIR: larkCliDir }),
+    // Phase 1: --no-wait --json → 立即返回 { device_code, verification_url, expires_in }
+    noWaitArgs: (domain) => ['auth', 'login', '--domain', domain, '--no-wait', '--json'],
+    // Phase 2: --device-code <code> --json → 阻塞直到用户完成授权
+    deviceCodeArgs: (code) => ['auth', 'login', '--device-code', code, '--json'],
+    domain: 'all',
+  },
+};
+
+// ─── 辅助：运行命令收集 stdout，返回 JSON ──────────────────────────────────
+
+function spawnJson(command, args, env) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn(command, args, {
+      env: { ...process.env, ...env },
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    let stdout = '';
+    let stderr = '';
+    proc.stdout.on('data', (d) => { stdout += d.toString(); });
+    proc.stderr.on('data', (d) => { stderr += d.toString(); });
+    proc.on('close', (code) => {
+      try {
+        resolve(JSON.parse(stdout.trim()));
+      } catch {
+        reject(new Error(stderr.trim() || `exit ${code}`));
+      }
+    });
+    proc.on('error', reject);
+  });
+}
+
+async function checkLarkCliAvailable() {
+  return new Promise((resolve) => {
+    exec('which lark-cli', { timeout: 3000 }, (err) => resolve(!err));
+  });
+}
+
+async function checkConfig(larkCliDir) {
+  try {
+    const configPath = path.join(larkCliDir, 'config.json');
+    const content = await fs.readFile(configPath, 'utf8');
+    const parsed = JSON.parse(content);
+    const appId = parsed?.apps?.[0]?.appId;
+    return { ok: !!appId, appId: appId || null };
+  } catch {
+    return { ok: false, appId: null };
+  }
+}
+
+async function checkAuth(larkCliDir) {
+  return new Promise((resolve) => {
+    const proc = spawn('lark-cli', ['auth', 'status'], {
+      env: { ...process.env, LARKSUITE_CLI_CONFIG_DIR: larkCliDir },
+      stdio: ['ignore', 'pipe', 'ignore'],
+    });
+
+    let stdout = '';
+    const timer = setTimeout(() => {
+      proc.kill();
+      resolve({ ok: false, userName: null, userOpenId: null });
+    }, 5000);
+
+    proc.stdout.on('data', (d) => { stdout += d.toString(); });
+
+    proc.on('close', () => {
+      clearTimeout(timer);
+      try {
+        const parsed = JSON.parse(stdout.trim());
+        if (parsed.userName && parsed.tokenStatus !== 'expired') {
+          resolve({ ok: true, userName: parsed.userName, userOpenId: parsed.userOpenId || null });
+          return;
+        }
+      } catch { /* ignore */ }
+      resolve({ ok: false, userName: null, userOpenId: null });
+    });
+
+    proc.on('error', () => {
+      clearTimeout(timer);
+      resolve({ ok: false, userName: null, userOpenId: null });
+    });
+  });
+}
+
+async function checkSkills(skillsDir) {
+  let installed = 0;
+  const installedList = [];
+  for (const name of LARK_CLI_SKILLS) {
+    try {
+      await fs.lstat(path.join(skillsDir, name));
+      installed++;
+      installedList.push(name);
+    } catch {
+      // not installed
+    }
+  }
+  return { ok: installed === LARK_CLI_SKILLS.length, installed, total: LARK_CLI_SKILLS.length, installedList };
+}
+
+// ─── 端点1：GET /status ─────────────────────────────────────────────────────
+
+router.get('/status', async (req, res) => {
+  try {
+    const userUuid = req.user.uuid;
+    const paths = getUserPaths(userUuid);
+
+    const larkCliInstalled = await checkLarkCliAvailable();
+    const envConfigured = !!(process.env.FEISHU_APP_ID && process.env.FEISHU_APP_SECRET);
+
+    const config = await checkConfig(paths.larkCliDir);
+    const auth = config.ok
+      ? await checkAuth(paths.larkCliDir)
+      : { ok: false, userName: null, userOpenId: null };
+    const skills = await checkSkills(paths.skillsDir);
+
+    const overall = config.ok && auth.ok && skills.ok ? 'installed' : 'incomplete';
+
+    res.json({ larkCliInstalled, envConfigured, config, auth, skills, overall });
+  } catch (err) {
+    console.error('[skill-suite] status error:', err);
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// ─── 端点2：POST /init-config ────────────────────────────────────────────────
+
+router.post('/init-config', async (req, res) => {
+  try {
+    const appId = process.env.FEISHU_APP_ID;
+    const appSecret = process.env.FEISHU_APP_SECRET;
+    if (!appId || !appSecret) {
+      return res.status(400).json({ error: '请先配置 FEISHU_APP_ID 和 FEISHU_APP_SECRET 环境变量' });
+    }
+
+    const userUuid = req.user.uuid;
+    const paths = getUserPaths(userUuid);
+    const configPath = path.join(paths.larkCliDir, 'config.json');
+
+    // 幂等：已有有效配置则跳过
+    const existing = await checkConfig(paths.larkCliDir);
+    if (existing.ok) {
+      return res.json({ success: true, alreadyExists: true, appId: existing.appId });
+    }
+
+    await fs.mkdir(paths.larkCliDir, { recursive: true });
+
+    const config = {
+      apps: [{
+        appId,
+        appSecret,
+        brand: 'feishu',
+        lang: 'zh',
+      }],
+    };
+    await fs.writeFile(configPath, JSON.stringify(config, null, 2), 'utf8');
+
+    res.json({ success: true, alreadyExists: false, appId });
+  } catch (err) {
+    console.error('[skill-suite] init-config error:', err);
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// ─── 端点3：POST /install-skills ────────────────────────────────────────────
+
+router.post('/install-skills', async (req, res) => {
+  try {
+    const userUuid = req.user.uuid;
+    const paths = getUserPaths(userUuid);
+    const publicPaths = getPublicPaths();
+
+    const publicRepoPath = path.join(publicPaths.skillsRepoDir, LARK_CLI_REPO_OWNER, LARK_CLI_REPO_NAME);
+
+    // 确保公共仓库已克隆
+    let repoExists = false;
+    try {
+      await fs.access(publicRepoPath);
+      repoExists = true;
+    } catch {
+      repoExists = false;
+    }
+
+    if (!repoExists) {
+      const parentDir = path.join(publicPaths.skillsRepoDir, LARK_CLI_REPO_OWNER);
+      await fs.mkdir(parentDir, { recursive: true });
+      await new Promise((resolve, reject) => {
+        const proc = spawn('git', ['clone', '--depth', '1', LARK_CLI_REPO_URL, publicRepoPath], {
+          stdio: 'inherit',
+        });
+        proc.on('close', (code) => {
+          if (code === 0) resolve();
+          else reject(new Error(`git clone failed with exit code ${code}`));
+        });
+        proc.on('error', reject);
+      });
+    }
+
+    // 确保用户的 skillsRepoDir 符号链接存在
+    const userRepoLinkParent = path.join(paths.skillsRepoDir, LARK_CLI_REPO_OWNER);
+    const userRepoLink = path.join(userRepoLinkParent, LARK_CLI_REPO_NAME);
+    await fs.mkdir(userRepoLinkParent, { recursive: true });
+    try {
+      await fs.lstat(userRepoLink);
+    } catch {
+      await fs.symlink(publicRepoPath, userRepoLink);
+    }
+
+    // 批量创建技能符号链接
+    await fs.mkdir(paths.skillsDir, { recursive: true });
+    const skillsSourceDir = path.join(publicRepoPath, 'skills');
+    const results = [];
+
+    for (const name of LARK_CLI_SKILLS) {
+      const sourcePath = path.join(skillsSourceDir, name);
+      const linkPath = path.join(paths.skillsDir, name);
+
+      // 检查源目录是否存在
+      try {
+        await fs.access(path.join(sourcePath, 'SKILL.md'));
+      } catch {
+        results.push({ name, ok: false, reason: 'not found in repo' });
+        continue;
+      }
+
+      // 幂等：先删除旧链接再创建
+      try {
+        await fs.lstat(linkPath);
+        await fs.unlink(linkPath);
+      } catch {
+        // 不存在，正常继续
+      }
+
+      try {
+        await fs.symlink(sourcePath, linkPath);
+        results.push({ name, ok: true });
+      } catch (err) {
+        results.push({ name, ok: false, reason: err.message });
+      }
+    }
+
+    const installed = results.filter((r) => r.ok).length;
+    res.json({ success: true, installed, total: LARK_CLI_SKILLS.length, results });
+  } catch (err) {
+    console.error('[skill-suite] install-skills error:', err);
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// ─── 端点4：GET /auth （SSE，策略模式，两阶段 JSON）──────────────────────
+
+router.get('/auth', async (req, res) => {
+  const type = req.query.type || 'feishu';
+  const strategy = AUTH_STRATEGIES[type];
+  if (!strategy) {
+    return res.status(400).json({ error: `Unknown auth type: ${type}` });
+  }
+
+  // 设置 SSE 响应头
+  res.setHeader('Content-Type', 'text/event-stream');
+  res.setHeader('Cache-Control', 'no-cache');
+  res.setHeader('Connection', 'keep-alive');
+  res.flushHeaders();
+
+  const sendEvent = (event, data) => {
+    res.write(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`);
+  };
+
+  let phase2Proc = null;
+
+  req.on('close', () => { phase2Proc?.kill(); });
+
+  try {
+    const userUuid = req.user.uuid;
+    const paths = getUserPaths(userUuid);
+    const env = strategy.getEnv(paths.larkCliDir);
+
+    // 检查 config 是否存在
+    const configCheck = await checkConfig(paths.larkCliDir);
+    if (!configCheck.ok) {
+      sendEvent('error', { message: '请先完成配置步骤' });
+      return res.end();
+    }
+
+    // Phase 1: --no-wait --json，立即获取 verification_url 和 device_code
+    const phase1 = await spawnJson('lark-cli', strategy.noWaitArgs(strategy.domain), env);
+    const { device_code, verification_url } = phase1;
+    sendEvent('url', { url: verification_url });
+
+    // Phase 2: --device-code，阻塞等待用户在浏览器完成授权
+    // 注意：--json 对 --device-code 子命令不生效（成功信息走 stderr 文本），
+    // 所以改为：exit code 0 = 成功，再调 auth status 取用户信息
+    await new Promise((resolve, reject) => {
+      phase2Proc = spawn('lark-cli', strategy.deviceCodeArgs(device_code), {
+        env: { ...process.env, ...env },
+        stdio: ['ignore', 'ignore', 'pipe'],
+      });
+
+      let stderr = '';
+      phase2Proc.stderr.on('data', (d) => { stderr += d.toString(); });
+
+      phase2Proc.on('close', async (code) => {
+        if (code === 0) {
+          // 授权成功，调 auth status 获取用户信息
+          const authInfo = await checkAuth(env.LARKSUITE_CLI_CONFIG_DIR);
+          sendEvent('success', { user: authInfo.userName || null });
+          resolve();
+        } else {
+          reject(new Error(stderr.trim() || `授权失败 (exit ${code})`));
+        }
+      });
+
+      phase2Proc.on('error', reject);
+    });
+  } catch (err) {
+    sendEvent('error', { message: err.message });
+  } finally {
+    res.end();
+  }
+});
+
+export default router;

package/server/services/user-directories.js

@@ -31,6 +31,7 @@ export function getUserPaths(userUuid) {
     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'),
+    larkCliDir: path.join(DATA_DIR, 'user-data', userUuid, '.lark-cli'),
   };
 }