feishu-user-plugin 1.1.3 → 1.2.1

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "feishu-user-plugin",
-  "version": "1.1.3",
+  "version": "1.2.0",
   "description": "All-in-one Feishu plugin for Claude Code — send messages as yourself, read chats, manage docs/tables/wiki. 33 tools + 9 skills, 3 auth layers.",
   "author": {
     "name": "EthanQC"

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "feishu-user-plugin",
-  "version": "1.1.3",
-  "description": "All-in-one Feishu plugin for Claude Code — send messages as yourself, read chats, manage docs/tables/wiki. 33 tools + 9 skills, 3 auth layers.",
+  "version": "1.2.1",
+  "description": "All-in-one Feishu plugin for Claude Code — send messages as yourself, read chats, manage docs/tables/wiki. 46 tools + 9 skills, 3 auth layers.",
   "main": "src/index.js",
   "bin": {
     "feishu-user-plugin": "src/cli.js"

package/src/cli.js

@@ -7,6 +7,7 @@
  *   npx feishu-user-plugin setup    → Interactive setup wizard
  *   npx feishu-user-plugin oauth    → Run OAuth flow for UAT
  *   npx feishu-user-plugin status   → Check auth status
+ *   npx feishu-user-plugin keepalive → Refresh cookie + UAT (for cron)
  */
 
 const cmd = process.argv[2];
@@ -21,6 +22,9 @@ switch (cmd) {
   case 'status':
     checkStatus();
     break;
+  case 'keepalive':
+    keepalive();
+    break;
   case 'help':
   case '--help':
   case '-h':
@@ -41,6 +45,7 @@ Commands:
   setup       Interactive setup wizard — writes MCP config
   oauth       Run OAuth flow to obtain user_access_token
   status      Check authentication status
+  keepalive   Refresh cookie + UAT to prevent expiration (for cron jobs)
   help        Show this help
 
 Quick Start (team members):
@@ -53,20 +58,85 @@ Quick Start (external users):
   2. npx feishu-user-plugin setup
   3. npx feishu-user-plugin oauth
   4. Restart Claude Code
+
+Auto-renewal (optional):
+  Add to crontab to keep tokens alive even when Claude Code is closed:
+  crontab -e → add: 0 */4 * * * npx feishu-user-plugin keepalive >> /tmp/feishu-keepalive.log 2>&1
 `);
 }
 
+async function keepalive() {
+  const { LarkUserClient } = require('./client');
+  const { LarkOfficialClient } = require('./official');
+  const { findMcpConfig, persistToConfig } = require('./config');
+
+  const found = findMcpConfig();
+  if (!found) {
+    console.error('[keepalive] No config found. Run: npx feishu-user-plugin setup');
+    process.exit(1);
+  }
+  const creds = found.serverEnv;
+  let ok = true;
+
+  // 1. Refresh Cookie
+  const cookie = creds.LARK_COOKIE;
+  if (cookie && cookie !== 'SETUP_NEEDED') {
+    try {
+      const client = new LarkUserClient(cookie);
+      await client.init();
+      // init() calls _getCsrfToken which refreshes sl_session
+      persistToConfig({ LARK_COOKIE: client.cookieStr });
+      console.log(`[keepalive] Cookie refreshed (user: ${client.userName})`);
+    } catch (e) {
+      console.error(`[keepalive] Cookie refresh FAILED: ${e.message}`);
+      ok = false;
+    }
+  }
+
+  // 2. Refresh UAT
+  const appId = creds.LARK_APP_ID;
+  const appSecret = creds.LARK_APP_SECRET;
+  const uat = creds.LARK_USER_ACCESS_TOKEN;
+  const rt = creds.LARK_USER_REFRESH_TOKEN;
+  if (appId && appSecret && uat && uat !== 'SETUP_NEEDED' && rt) {
+    try {
+      const official = new LarkOfficialClient(appId, appSecret);
+      official._uat = uat;
+      official._uatRefresh = rt;
+      official._uatExpires = 0; // force refresh
+      await official._refreshUAT(); // refreshes + persists automatically
+      console.log('[keepalive] UAT refreshed');
+    } catch (e) {
+      console.error(`[keepalive] UAT refresh FAILED: ${e.message}`);
+      ok = false;
+    }
+  }
+
+  if (ok) {
+    console.log('[keepalive] All tokens refreshed successfully');
+  }
+  process.exit(ok ? 0 : 1);
+}
+
 async function checkStatus() {
   const { LarkUserClient } = require('./client');
   const { LarkOfficialClient } = require('./official');
-  const path = require('path');
-  require('dotenv').config({ path: path.join(__dirname, '..', '.env') });
+  const { findMcpConfig } = require('./config');
+
+  const found = findMcpConfig();
+  const creds = found ? found.serverEnv : {};
 
   console.log('=== feishu-user-plugin Auth Status ===\n');
+  if (found) {
+    console.log(`Config: ${found.configPath}${found.projectPath ? ` (project: ${found.projectPath})` : ''}`);
+  } else {
+    console.log('Config: NOT FOUND (run: npx feishu-user-plugin setup)');
+  }
+  console.log('');
 
   // Cookie
-  const cookie = process.env.LARK_COOKIE;
-  if (cookie) {
+  const cookie = creds.LARK_COOKIE;
+  if (cookie && cookie !== 'SETUP_NEEDED') {
     try {
       const client = new LarkUserClient(cookie);
       await client.init();
@@ -79,21 +149,24 @@ async function checkStatus() {
   }
 
   // App credentials
-  const appId = process.env.LARK_APP_ID;
-  const appSecret = process.env.LARK_APP_SECRET;
+  const appId = creds.LARK_APP_ID;
+  const appSecret = creds.LARK_APP_SECRET;
   console.log(`App credentials: ${appId && appSecret ? 'OK' : 'NOT SET'}`);
 
   // UAT
-  const uat = process.env.LARK_USER_ACCESS_TOKEN;
-  const rt = process.env.LARK_USER_REFRESH_TOKEN;
-  if (uat) {
+  const uat = creds.LARK_USER_ACCESS_TOKEN;
+  const rt = creds.LARK_USER_REFRESH_TOKEN;
+  if (uat && uat !== 'SETUP_NEEDED') {
     console.log(`UAT: SET (refresh_token: ${rt ? 'YES' : 'NO'})`);
     if (appId && appSecret) {
       const official = new LarkOfficialClient(appId, appSecret);
-      official.loadUAT();
+      // Set UAT fields directly (bypassing loadUAT which reads from process.env)
+      official._uat = uat;
+      official._uatRefresh = rt || null;
+      official._uatExpires = parseInt(creds.LARK_UAT_EXPIRES || '0');
       try {
-        const chats = await official.listChatsAsUser({ pageSize: 1 });
-        console.log(`  UAT test: OK (can list chats)`);
+        await official.listChatsAsUser({ pageSize: 1 });
+        console.log('  UAT test: OK (can list chats)');
       } catch (e) {
         console.log(`  UAT test: FAILED — ${e.message}`);
       }

package/src/client.js

@@ -90,7 +90,10 @@ class LarkUserClient {
     this._heartbeatTimer = setInterval(async () => {
       try {
         await this._getCsrfToken();
-        console.error('[feishu-user-plugin] Cookie heartbeat: session refreshed');
+        // Lazy require to avoid circular dependency at module load time
+        const { persistToConfig } = require('./config');
+        persistToConfig({ LARK_COOKIE: this.cookieStr });
+        console.error('[feishu-user-plugin] Cookie heartbeat: session refreshed and persisted');
       } catch (e) {
         console.error('[feishu-user-plugin] Cookie heartbeat failed:', e.message);
       }
@@ -252,7 +255,8 @@ class LarkUserClient {
           const propBuf = this._encode('TextProperty', { content: elem.userId });
           dictionary[elemId] = { tag: 5, property: propBuf };
         } else if (elem.tag === 'a') {
-          const propBuf = this._encode('TextProperty', { content: elem.text || elem.href });
+          // Link element: content stores the URL, display text goes through innerText
+          const propBuf = this._encode('TextProperty', { content: elem.href || elem.text || '' });
           dictionary[elemId] = { tag: 6, property: propBuf };
         }
       }

package/src/config.js

@@ -0,0 +1,188 @@
+const fs = require('fs');
+const path = require('path');
+
+const SERVER_NAMES = ['feishu-user-plugin', 'feishu'];
+
+/**
+ * Search an mcpServers object for a feishu-user-plugin entry.
+ * Returns { serverName, serverEnv } or null.
+ */
+function _findInServers(servers) {
+  if (!servers || typeof servers !== 'object') return null;
+  for (const name of SERVER_NAMES) {
+    if (servers[name]) {
+      if (!servers[name].env) servers[name].env = {};
+      return { serverName: name, serverEnv: servers[name].env };
+    }
+  }
+  return null;
+}
+
+/**
+ * Discover the MCP config file containing feishu-user-plugin server entry.
+ *
+ * Search order:
+ *   1. ~/.claude.json — top-level mcpServers
+ *   2. ~/.claude.json — projects[*].mcpServers (Claude Code project-level config)
+ *   3. ~/.claude/.claude.json — same two-level search
+ *   4. <cwd>/.mcp.json — top-level mcpServers (reliable in CLI mode)
+ *
+ * Returns { configPath, config, serverName, serverEnv, projectPath? } or null.
+ */
+function findMcpConfig() {
+  const home = process.env.HOME;
+  const candidates = [
+    ...(home ? [
+      path.join(home, '.claude.json'),
+      path.join(home, '.claude', '.claude.json'),
+    ] : []),
+    path.join(process.cwd(), '.mcp.json'),
+  ];
+
+  for (const configPath of candidates) {
+    try {
+      const raw = fs.readFileSync(configPath, 'utf8');
+      const config = JSON.parse(raw);
+
+      // Strategy 1: top-level mcpServers
+      const topLevel = _findInServers(config.mcpServers);
+      if (topLevel) {
+        return { configPath, config, ...topLevel, projectPath: null };
+      }
+
+      // Strategy 2: projects[*].mcpServers (Claude Code nests project-level config here)
+      if (config.projects) {
+        for (const [projPath, projConfig] of Object.entries(config.projects)) {
+          const nested = _findInServers(projConfig.mcpServers);
+          if (nested) {
+            return { configPath, config, ...nested, projectPath: projPath };
+          }
+        }
+      }
+
+      // Strategy 3: .mcp.json uses top-level keys as server names (no mcpServers wrapper)
+      const bare = _findInServers(config);
+      if (bare) {
+        return { configPath, config, ...bare, projectPath: null };
+      }
+    } catch (e) {
+      // Only warn if the file exists but is invalid (not for missing files)
+      if (e.code !== 'ENOENT') {
+        console.error(`[feishu-user-plugin] Warning: Failed to parse ${configPath}: ${e.message}`);
+      }
+    }
+  }
+  return null;
+}
+
+/**
+ * Read all LARK_* credentials from the discovered MCP config.
+ * Returns an object with all env vars, or {} if no config found.
+ */
+function readCredentials() {
+  const found = findMcpConfig();
+  if (!found) return {};
+  return { ...found.serverEnv };
+}
+
+/**
+ * Persist key-value updates into the MCP config's env block.
+ * Uses findMcpConfig() to locate the correct entry, then writes back.
+ * Returns true if persisted successfully, false otherwise.
+ */
+function persistToConfig(updates) {
+  try {
+    const found = findMcpConfig();
+    if (!found) {
+      console.error('[feishu-user-plugin] WARNING: No MCP config found. Update your config manually.');
+      return false;
+    }
+
+    const { configPath, config, serverName, projectPath } = found;
+
+    // Navigate to the correct env object
+    let env;
+    if (projectPath) {
+      env = config.projects[projectPath].mcpServers[serverName].env;
+    } else if (config.mcpServers?.[serverName]) {
+      env = config.mcpServers[serverName].env;
+    } else {
+      env = config[serverName].env;
+    }
+
+    Object.assign(env, updates);
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n');
+    console.error(`[feishu-user-plugin] Config persisted to ${configPath}${projectPath ? ` (project: ${projectPath})` : ''}`);
+    return true;
+  } catch (e) {
+    console.error(`[feishu-user-plugin] Failed to persist config: ${e.message}`);
+    return false;
+  }
+}
+
+/**
+ * Write a complete feishu-user-plugin MCP server entry to a config file.
+ * Used by the setup wizard.
+ *
+ * If an existing config is found via findMcpConfig(), updates it in-place
+ * (preserving its location — top-level or project-level).
+ * Otherwise, writes to ~/.claude.json top-level mcpServers.
+ *
+ * @param {object} env - The env vars to write
+ * @param {string} [configPath] - Override the target config file path
+ * @param {string} [projectPath] - If writing to a project-level entry
+ * @returns {{ configPath: string }} The path that was written
+ */
+function writeNewConfig(env, configPath, projectPath) {
+  if (!configPath) {
+    configPath = path.join(process.env.HOME || '', '.claude.json');
+  }
+
+  if (projectPath) {
+    // Verify the project entry still exists; warn if it was removed between discovery and write
+    let existing = {};
+    try { existing = JSON.parse(fs.readFileSync(configPath, 'utf8')); } catch {}
+    if (!existing.projects?.[projectPath]) {
+      console.error(`[feishu-user-plugin] Warning: project entry "${projectPath}" not found in ${configPath}, writing to top-level mcpServers`);
+      projectPath = null;
+    }
+  }
+
+  let config = {};
+  try {
+    config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+  } catch {}
+
+  const serverEntry = {
+    command: 'npx',
+    args: ['-y', 'feishu-user-plugin'],
+    env,
+  };
+
+  if (projectPath && config.projects?.[projectPath]) {
+    // Write into existing project-level config
+    if (!config.projects[projectPath].mcpServers) config.projects[projectPath].mcpServers = {};
+    config.projects[projectPath].mcpServers['feishu-user-plugin'] = serverEntry;
+    if (config.projects[projectPath].mcpServers.feishu) {
+      delete config.projects[projectPath].mcpServers.feishu;
+    }
+  } else if (configPath.endsWith('.mcp.json') && !config.mcpServers) {
+    // Bare .mcp.json format: server entries at top level (no mcpServers wrapper)
+    config['feishu-user-plugin'] = serverEntry;
+    if (config.feishu) {
+      delete config.feishu;
+    }
+  } else {
+    // Write to top-level mcpServers (default for ~/.claude.json)
+    if (!config.mcpServers) config.mcpServers = {};
+    config.mcpServers['feishu-user-plugin'] = serverEntry;
+    if (config.mcpServers.feishu) {
+      delete config.mcpServers.feishu;
+    }
+  }
+
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n');
+  return { configPath };
+}
+
+module.exports = { findMcpConfig, readCredentials, persistToConfig, writeNewConfig, SERVER_NAMES };