opencode-remote-control 0.1.3 → 0.2.0

package/README.md

@@ -12,7 +12,7 @@
 </p>
 
 <p align="center">
-  Control OpenCode from anywhere via Telegram.
+  Control OpenCode from anywhere via Telegram or Feishu.
 </p>
 
 ## Installation
@@ -26,7 +26,9 @@ pnpm install -g opencode-remote-control
 bun install -g opencode-remote-control
 ```
 
-## Setup
+## Quick Start
+
+### Telegram Setup
 
 On first run, you'll be prompted for a Telegram bot token:
 
@@ -36,12 +38,26 @@ On first run, you'll be prompted for a Telegram bot token:
 
 Token is saved to `~/.opencode-remote/.env`
 
+### Feishu Setup
+
+Run the config command for Feishu:
+
+```bash
+opencode-remote config-feishu
+```
+
+Follow the interactive guide to configure your Feishu bot. For detailed setup instructions, see [Feishu Setup Guide](./docs/FEISHU_SETUP_EN.md) or [飞书配置指南](./docs/FEISHU_SETUP.md).
+
 ## Usage
 
 ```bash
-opencode-remote         # Start the bot
-opencode-remote config  # Reconfigure token
-opencode-remote help    # Show help
+opencode-remote              # Start all configured bots
+opencode-remote start        # Start all configured bots
+opencode-remote telegram     # Start Telegram bot only
+opencode-remote feishu       # Start Feishu bot only
+opencode-remote config       # Configure a channel (interactive)
+opencode-remote config-feishu # Configure Feishu directly
+opencode-remote help         # Show help
 ```
 
 ## Install from Source
@@ -54,7 +70,9 @@ bun run build
 node dist/cli.js
 ```
 
-## Telegram Commands
+## Bot Commands
+
+Both Telegram and Feishu support the same commands:
 
 | Command | Description |
 |--------|-------------|
@@ -66,9 +84,12 @@ node dist/cli.js
 | `/diff` | View pending diff |
 | `/files` | List changed files |
 | `/reset` | Reset session |
+| `/retry` | Retry connection |
 
 ## How It Works
 
+### Telegram (Polling Mode)
+
 ```
 ┌─────────────────┐                    ┌──────────────────┐
 │  Telegram App   │                    │  Telegram Server │
@@ -91,13 +112,38 @@ node dist/cli.js
 └─────────────────────────────────────────────────────────┘
 ```
 
-The bot uses **Polling Mode** to fetch messages from Telegram servers, requiring no tunnel or public IP configuration.
+The Telegram bot uses **Polling Mode** to fetch messages from Telegram servers, requiring no tunnel or public IP configuration.
+
+### Feishu (Webhook Mode)
+
+```
+┌─────────────┐    ┌─────────────┐    ┌─────────────┐
+│  Feishu     │───▶│  Feishu     │───▶│   Webhook   │
+│  Client     │    │  Server     │    │  (ngrok)    │
+└─────────────┘    └─────────────┘    └──────┬──────┘
+                                             │
+                                             ▼
+                                      ┌─────────────┐
+                                      │ Feishu Bot  │
+                                      │  (port 3001)│
+                                      └──────┬──────┘
+                                             │
+                                             ▼
+                                      ┌─────────────┐
+                                      │  OpenCode   │
+                                      │    SDK      │
+                                      └─────────────┘
+```
+
+The Feishu bot uses **Webhook Mode** and requires a tunnel (ngrok/cloudflared) to receive messages.
 
 ## Requirements
 
 - Node.js >= 18.0.0
 - [OpenCode](https://github.com/opencode-ai/opencode) installed
-- Telegram account
+- Telegram account (for Telegram bot)
+- Feishu account (for Feishu bot)
+- ngrok or cloudflared (for Feishu webhook)
 
 ## Contributing
 

package/dist/cli.js

@@ -4,13 +4,14 @@ import { existsSync, writeFileSync, readFileSync, mkdirSync } from 'fs';
 import { homedir } from 'os';
 import { join } from 'path';
 import { startBot } from './telegram/bot.js';
+import { startFeishuBot } from './feishu/bot.js';
 const CONFIG_DIR = join(homedir(), '.opencode-remote');
 const CONFIG_FILE = join(CONFIG_DIR, '.env');
 function printBanner() {
     console.log(`
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
   OpenCode Remote Control
-  Control OpenCode from Telegram
+  Control OpenCode from Telegram or Feishu
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 `);
 }
@@ -19,16 +20,45 @@ function printHelp() {
 Usage: opencode-remote [command]
 
 Commands:
-  start     Start the bot (default)
-  config    Configure Telegram bot token
-  help      Show this help message
+  start              Start all configured bots (default)
+  telegram           Start Telegram bot only
+  feishu             Start Feishu bot only
+  config             Configure a channel (interactive selection)
+  config-feishu      Configure Feishu bot directly
+  help               Show this help message
 
 Examples:
-  opencode-remote           # Start the bot
-  opencode-remote start     # Start the bot
-  opencode-remote config    # Configure token
+  opencode-remote              # Start all bots
+  opencode-remote start        # Start all bots
+  opencode-remote telegram     # Start Telegram only
+  opencode-remote feishu       # Start Feishu only
+  opencode-remote config       # Interactive channel selection
+  opencode-remote config-feishu # Configure Feishu directly
 `);
 }
+async function promptChannel() {
+    console.log('\n📝 Select a channel to configure:');
+    console.log('');
+    console.log('  1. Telegram');
+    console.log('  2. Feishu (飞书)');
+    console.log('');
+    process.stdout.write('Enter your choice (1 or 2): ');
+    const choice = await new Promise((resolve) => {
+        process.stdin.setEncoding('utf8');
+        process.stdin.once('data', (chunk) => {
+            resolve(chunk.toString().trim());
+        });
+    });
+    if (choice === '1' || choice.toLowerCase() === 'telegram') {
+        return 'telegram';
+    }
+    else if (choice === '2' || choice.toLowerCase() === 'feishu') {
+        return 'feishu';
+    }
+    // Default to telegram if invalid input
+    console.log('Invalid choice, defaulting to Telegram');
+    return 'telegram';
+}
 async function promptToken() {
     console.log('\n📝 Setup required: Telegram Bot Token');
     console.log('\nHow to get a token:');
@@ -47,62 +77,281 @@ async function promptToken() {
     });
     return token;
 }
+async function promptFeishuConfig() {
+    console.log('\n📝 Step 1: Create Feishu App');
+    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+    console.log('');
+    console.log('  1. Go to https://open.feishu.cn/app');
+    console.log('  2. Click "创建企业自建应用" (Create enterprise app)');
+    console.log('  3. Fill in app name and description');
+    console.log('  4. Go to "凭证与基础信息" (Credentials) page');
+    console.log('');
+    process.stdout.write('Enter your App ID: ');
+    const appId = await new Promise((resolve) => {
+        process.stdin.setEncoding('utf8');
+        process.stdin.once('data', (chunk) => {
+            resolve(chunk.toString().trim());
+        });
+    });
+    process.stdout.write('Enter your App Secret: ');
+    const appSecret = await new Promise((resolve) => {
+        process.stdin.setEncoding('utf8');
+        process.stdin.once('data', (chunk) => {
+            resolve(chunk.toString().trim());
+        });
+    });
+    return { appId, appSecret };
+}
+function showFeishuSetupGuide() {
+    console.log('');
+    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+    console.log('  📋 Step 2: Configure App Permissions');
+    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+    console.log('');
+    console.log('  Go to "权限管理" (Permission Management) page');
+    console.log('  Search and enable these permissions:');
+    console.log('');
+    console.log('  ┌────────────────────────────────────────────────────┐');
+    console.log('  │ Permission                              │ Scope    │');
+    console.log('  ├────────────────────────────────────────────────────┤');
+    console.log('  │ im:message                      获取与发送消息  │');
+    console.log('  │ im:message:send_as_bot          以应用身份发消息 │');
+    console.log('  │ im:message:receive_as_bot       接收机器人消息   │');
+    console.log('  └────────────────────────────────────────────────────┘');
+    console.log('');
+    console.log('  💡 TIP: Copy the JSON below and use "批量添加" feature:');
+    console.log('');
+    console.log('  ┌────────────────────────────────────────────────────┐');
+    console.log('  │ [');
+    console.log('  │   "im:message",');
+    console.log('  │   "im:message:send_as_bot",');
+    console.log('  │   "im:message:receive_as_bot"');
+    console.log('  │ ]');
+    console.log('  └────────────────────────────────────────────────────┘');
+    console.log('');
+    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+    console.log('  🤖 Step 3: Enable Robot Capability');
+    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+    console.log('');
+    console.log('  1. Go to "应用能力" (App Capabilities) → "机器人" (Robot)');
+    console.log('  2. Click "启用机器人" (Enable Robot)');
+    console.log('  3. Set robot name and description');
+    console.log('');
+    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+    console.log('  🔗 Step 4: Configure Event Subscription');
+    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+    console.log('');
+    console.log('  1. Start the bot locally:');
+    console.log('     $ opencode-remote feishu');
+    console.log('');
+    console.log('  2. Expose webhook with ngrok/cloudflared:');
+    console.log('     $ ngrok http 3001');
+    console.log('');
+    console.log('  3. Go to "事件订阅" (Event Subscription) page');
+    console.log('  4. Set Request URL: https://your-ngrok-url/feishu/webhook');
+    console.log('  5. Add event: im.message.receive_v1');
+    console.log('');
+    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+    console.log('  📤 Step 5: Publish App');
+    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+    console.log('');
+    console.log('  1. Go to "版本管理与发布" (Version & Publish)');
+    console.log('  2. Click "创建版本" (Create Version)');
+    console.log('  3. Fill in version info and submit for review');
+    console.log('  4. After approval, click "发布" (Publish)');
+    console.log('  5. Search your bot in Feishu and start chatting!');
+    console.log('');
+    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+}
 async function getConfig() {
-    // Check environment variable first (must be non-empty)
-    const envToken = process.env.TELEGRAM_BOT_TOKEN;
-    if (envToken && envToken.trim()) {
-        return envToken.trim();
-    }
+    const config = {
+        opencodeServerUrl: process.env.OPENCODE_SERVER_URL || 'http://localhost:3000',
+        tunnelUrl: process.env.TUNNEL_URL || '',
+        sessionIdleTimeoutMs: parseInt(process.env.SESSION_IDLE_TIMEOUT_MS || '1800000', 10),
+        cleanupIntervalMs: parseInt(process.env.CLEANUP_INTERVAL_MS || '300000', 10),
+        approvalTimeoutMs: parseInt(process.env.APPROVAL_TIMEOUT_MS || '300000', 10),
+    };
     // Check config file
     if (existsSync(CONFIG_FILE)) {
         const content = readFileSync(CONFIG_FILE, 'utf-8');
-        const match = content.match(/TELEGRAM_BOT_TOKEN=(.+)/);
-        if (match) {
-            const token = match[1].trim();
+        // Parse Telegram token
+        const telegramMatch = content.match(/TELEGRAM_BOT_TOKEN=(.+)/);
+        if (telegramMatch) {
+            const token = telegramMatch[1].trim();
             if (token && token !== 'your_bot_token_here') {
-                return token;
+                config.telegramBotToken = token;
             }
         }
+        // Parse Feishu config
+        const feishuAppIdMatch = content.match(/FEISHU_APP_ID=(.+)/);
+        if (feishuAppIdMatch) {
+            config.feishuAppId = feishuAppIdMatch[1].trim();
+        }
+        const feishuSecretMatch = content.match(/FEISHU_APP_SECRET=(.+)/);
+        if (feishuSecretMatch) {
+            config.feishuAppSecret = feishuSecretMatch[1].trim();
+        }
+    }
+    // Check environment variables
+    if (process.env.TELEGRAM_BOT_TOKEN?.trim()) {
+        config.telegramBotToken = process.env.TELEGRAM_BOT_TOKEN.trim();
+    }
+    if (process.env.FEISHU_APP_ID?.trim()) {
+        config.feishuAppId = process.env.FEISHU_APP_ID.trim();
+    }
+    if (process.env.FEISHU_APP_SECRET?.trim()) {
+        config.feishuAppSecret = process.env.FEISHU_APP_SECRET.trim();
     }
     // Check local .env
     const localEnv = join(process.cwd(), '.env');
     if (existsSync(localEnv)) {
         const content = readFileSync(localEnv, 'utf-8');
-        const match = content.match(/TELEGRAM_BOT_TOKEN=(.+)/);
-        if (match) {
-            const token = match[1].trim();
-            if (token && token !== 'your_bot_token_here') {
-                return token;
+        const telegramMatch = content.match(/TELEGRAM_BOT_TOKEN=(.+)/);
+        if (telegramMatch) {
+            const token = telegramMatch[1].trim();
+            if (token && token !== 'your_bot_token_here' && !config.telegramBotToken) {
+                config.telegramBotToken = token;
             }
         }
+        const feishuAppIdMatch = content.match(/FEISHU_APP_ID=(.+)/);
+        if (feishuAppIdMatch) {
+            config.feishuAppId = feishuAppIdMatch[1].trim();
+        }
+        const feishuSecretMatch = content.match(/FEISHU_APP_SECRET=(.+)/);
+        if (feishuSecretMatch) {
+            config.feishuAppSecret = feishuSecretMatch[1].trim();
+        }
     }
-    return null;
+    return config;
 }
 async function saveConfig(token) {
     // Create config directory if needed
     if (!existsSync(CONFIG_DIR)) {
         mkdirSync(CONFIG_DIR, { recursive: true });
     }
-    writeFileSync(CONFIG_FILE, `TELEGRAM_BOT_TOKEN=${token}\n`);
+    // Read existing config
+    let existing = '';
+    if (existsSync(CONFIG_FILE)) {
+        existing = readFileSync(CONFIG_FILE, 'utf-8');
+    }
+    // Add or update Telegram token
+    const lines = existing.split('\n').filter(line => !line.startsWith('TELEGRAM_BOT_TOKEN='));
+    lines.push(`TELEGRAM_BOT_TOKEN=${token}`);
+    writeFileSync(CONFIG_FILE, lines.join('\n'));
     console.log(`\n✅ Token saved to ${CONFIG_FILE}`);
 }
+async function saveFeishuConfig(appId, appSecret) {
+    // Create config directory if needed
+    if (!existsSync(CONFIG_DIR)) {
+        mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+    // Read existing config
+    let existing = '';
+    if (existsSync(CONFIG_FILE)) {
+        existing = readFileSync(CONFIG_FILE, 'utf-8');
+    }
+    // Filter out old Feishu config
+    const lines = existing.split('\n').filter(line => !line.startsWith('FEISHU_APP_ID=') &&
+        !line.startsWith('FEISHU_APP_SECRET='));
+    // Add new Feishu config
+    lines.push(`FEISHU_APP_ID=${appId}`);
+    lines.push(`FEISHU_APP_SECRET=${appSecret}`);
+    writeFileSync(CONFIG_FILE, lines.join('\n'));
+    console.log(`\n✅ Feishu config saved to ${CONFIG_FILE}`);
+    // Show setup guide
+    showFeishuSetupGuide();
+}
 async function runConfig() {
     printBanner();
-    const token = await promptToken();
-    if (!token || token === 'your_bot_token_here') {
-        console.log('\n❌ Invalid token. Please try again.');
+    // Let user select channel
+    const channel = await promptChannel();
+    if (channel === 'telegram') {
+        const token = await promptToken();
+        if (!token || token === 'your_bot_token_here') {
+            console.log('\n❌ Invalid token. Please try again.');
+            process.exit(1);
+        }
+        await saveConfig(token);
+        console.log('\n🚀 Ready! Run `opencode-remote` to start the bot.');
+    }
+    else {
+        const { appId, appSecret } = await promptFeishuConfig();
+        if (!appId || !appSecret) {
+            console.log('\n❌ Invalid credentials. Please try again.');
+            process.exit(1);
+        }
+        await saveFeishuConfig(appId, appSecret);
+        console.log('\n🚀 Ready! Run `opencode-remote feishu` to start the Feishu bot.');
+    }
+    process.exit(0);
+}
+async function runConfigFeishu() {
+    printBanner();
+    const { appId, appSecret } = await promptFeishuConfig();
+    if (!appId || !appSecret) {
+        console.log('\n❌ Invalid credentials. Please try again.');
         process.exit(1);
     }
-    await saveConfig(token);
+    await saveFeishuConfig(appId, appSecret);
     console.log('\n🚀 Ready! Run `opencode-remote` to start the bot.');
     process.exit(0);
 }
+function hasTelegramConfig(config) {
+    return !!(config.telegramBotToken?.trim());
+}
+function hasFeishuConfig(config) {
+    return !!(config.feishuAppId?.trim() &&
+        config.feishuAppSecret?.trim());
+}
 async function runStart() {
-    const token = await getConfig();
-    // Set token in environment for startBot to use
-    if (token) {
-        process.env.TELEGRAM_BOT_TOKEN = token;
+    const config = await getConfig();
+    printBanner();
+    // Check what's configured
+    const hasTelegram = hasTelegramConfig(config);
+    const hasFeishu = hasFeishuConfig(config);
+    if (!hasTelegram && !hasFeishu) {
+        console.log('❌ No bots configured!');
+        console.log('\nRun one of:');
+        console.log('  opencode-remote config        # Configure Telegram');
+        console.log('  opencode-remote config-feishu # Configure Feishu');
+        process.exit(1);
+    }
+    // Start bots
+    const promises = [];
+    if (hasTelegram) {
+        console.log('🤖 Starting Telegram bot...');
+        process.env.TELEGRAM_BOT_TOKEN = config.telegramBotToken;
+        promises.push(startBot().catch((err) => {
+            console.error('Telegram bot failed:', err);
+            return { status: 'rejected', reason: err };
+        }));
+    }
+    if (hasFeishu) {
+        console.log('🤖 Starting Feishu bot...');
+        promises.push(startFeishuBot(config).catch((err) => {
+            console.error('Feishu bot failed:', err);
+            return { status: 'rejected', reason: err };
+        }));
     }
+    // Wait for all bots
+    const results = await Promise.allSettled(promises);
+    const failed = results.filter((r) => r.status === 'rejected');
+    if (failed.length > 0) {
+        console.log(`\n⚠️ ${failed.length} bot(s) failed to start`);
+        process.exit(1);
+    }
+    console.log('\n✅ All bots started!');
+}
+async function runTelegramOnly() {
+    const config = await getConfig();
+    if (!hasTelegramConfig(config)) {
+        console.log('❌ Telegram bot not configured!');
+        console.log('\nRun: opencode-remote config');
+        process.exit(1);
+    }
+    printBanner();
+    console.log('🤖 Starting Telegram bot...');
+    process.env.TELEGRAM_BOT_TOKEN = config.telegramBotToken;
     try {
         await startBot();
     }
@@ -111,6 +360,23 @@ async function runStart() {
         process.exit(1);
     }
 }
+async function runFeishuOnly() {
+    const config = await getConfig();
+    if (!hasFeishuConfig(config)) {
+        console.log('❌ Feishu bot not configured!');
+        console.log('\nRun: opencode-remote config-feishu');
+        process.exit(1);
+    }
+    printBanner();
+    console.log('🤖 Starting Feishu bot...');
+    try {
+        await startFeishuBot(config);
+    }
+    catch (error) {
+        console.error('Failed to start:', error);
+        process.exit(1);
+    }
+}
 // Main CLI
 const args = process.argv.slice(2);
 const command = args[0] || 'start';
@@ -118,9 +384,18 @@ switch (command) {
     case 'start':
         runStart();
         break;
+    case 'telegram':
+        runTelegramOnly();
+        break;
+    case 'feishu':
+        runFeishuOnly();
+        break;
     case 'config':
         runConfig();
         break;
+    case 'config-feishu':
+        runConfigFeishu();
+        break;
     case 'help':
     case '--help':
     case '-h':

package/dist/core/handler-common.js

@@ -13,13 +13,13 @@ export function createHandler(deps) {
                 return;
             }
             // It's a prompt - send to OpenCode
-            await deps.sendTyping(ctx.threadId);
+            await deps.sendTypingIndicator(ctx.threadId);
             // TODO: Actually send to OpenCode SDK
             // For now, echo back
-            await deps.sendMessage(ctx.threadId, TEMPLATES.thinking());
+            await deps.reply(ctx.threadId, TEMPLATES.thinking());
             // Simulate response
             setTimeout(async () => {
-                await deps.sendMessage(ctx.threadId, TEMPLATES.taskCompleted([
+                await deps.reply(ctx.threadId, TEMPLATES.taskCompleted([
                     { path: 'src/example.ts', additions: 10, deletions: 2 }
                 ]));
             }, 1000);
@@ -31,7 +31,7 @@ export function createHandler(deps) {
             switch (command) {
                 case '/start':
                 case '/help':
-                    await deps.sendMessage(ctx.threadId, TEMPLATES.botStarted());
+                    await deps.reply(ctx.threadId, TEMPLATES.botStarted());
                     break;
                 case '/approve':
                     await this.handleApprove(ctx, session);
@@ -46,67 +46,67 @@ export function createHandler(deps) {
                     await this.handleFiles(ctx, session);
                     break;
                 case '/status':
-                    await deps.sendMessage(ctx.threadId, `✅ Connected\n\n💬 Session: ${session.id.slice(0, 8)}\n⏰ Idle: ${Math.round((Date.now() - session.lastActivity) / 1000)}s`);
+                    await deps.reply(ctx.threadId, `✅ Connected\n\n💬 Session: ${session.id.slice(0, 8)}\n⏰ Idle: ${Math.round((Date.now() - session.lastActivity) / 1000)}s`);
                     break;
                 case '/reset':
                     session.pendingApprovals = [];
                     session.opencodeSessionId = undefined;
-                    await deps.sendMessage(ctx.threadId, '🔄 Session reset. Start fresh!');
+                    await deps.reply(ctx.threadId, '🔄 Session reset. Start fresh!');
                     break;
                 default:
-                    await deps.sendMessage(ctx.threadId, `${EMOJI.WARNING} Unknown command: ${command}\n\nTry /help`);
+                    await deps.reply(ctx.threadId, `${EMOJI.WARNING} Unknown command: ${command}\n\nTry /help`);
             }
         },
         // Handle /approve
         async handleApprove(ctx, session) {
             const pending = session.pendingApprovals[0];
             if (!pending) {
-                await deps.sendMessage(ctx.threadId, '🤷 Nothing to approve right now');
+                await deps.reply(ctx.threadId, '🤷 Nothing to approve right now');
                 return;
             }
             // Resolve the approval
             // TODO: Actually apply changes via OpenCode SDK
-            await deps.sendMessage(ctx.threadId, TEMPLATES.approved());
+            await deps.reply(ctx.threadId, TEMPLATES.approved());
         },
         // Handle /reject
         async handleReject(ctx, session) {
             const pending = session.pendingApprovals[0];
             if (!pending) {
-                await deps.sendMessage(ctx.threadId, '🤷 Nothing to reject right now');
+                await deps.reply(ctx.threadId, '🤷 Nothing to reject right now');
                 return;
             }
             session.pendingApprovals.shift();
-            await deps.sendMessage(ctx.threadId, TEMPLATES.rejected());
+            await deps.reply(ctx.threadId, TEMPLATES.rejected());
         },
         // Handle /diff
         async handleDiff(ctx, session) {
             const pending = session.pendingApprovals[0];
             if (!pending || !pending.files?.length) {
-                await deps.sendMessage(ctx.threadId, '📄 No pending changes to show');
+                await deps.reply(ctx.threadId, '📄 No pending changes to show');
                 return;
             }
             // TODO: Get actual diff from OpenCode SDK
             const diffPreview = pending.files.map(f => `--- a/${f.path}\n+++ b/${f.path}\n@@ changes +${f.additions} +${f.deletions} @@`).join('\n');
             const messages = splitMessage(`\`\`\`diff\n${diffPreview}\n\`\`\``);
             for (const msg of messages) {
-                await deps.sendMessage(ctx.threadId, msg);
+                await deps.reply(ctx.threadId, msg);
             }
         },
         // Handle /files
         async handleFiles(ctx, session) {
             const pending = session.pendingApprovals[0];
             if (!pending || !pending.files?.length) {
-                await deps.sendMessage(ctx.threadId, '📄 No files changed in this session');
+                await deps.reply(ctx.threadId, '📄 No files changed in this session');
                 return;
             }
             const fileList = pending.files.map(f => `• ${f.path} (+${f.additions}, -${f.deletions})`).join('\n');
-            await deps.sendMessage(ctx.threadId, `📄 Changed files:\n${fileList}`);
+            await deps.reply(ctx.threadId, `📄 Changed files:\n${fileList}`);
         },
         // Request approval from user
         async requestApproval(ctx, session, type, data) {
             const request = createApprovalRequest(session, type, data);
             const message = formatApprovalMessage(request);
-            await deps.sendMessage(ctx.threadId, message);
+            await deps.reply(ctx.threadId, message);
             // Wait for user response
             return waitForApproval(request);
         }

package/dist/core/types.js

@@ -15,7 +15,12 @@ export const EMOJI = {
 };
 export function loadConfig() {
     return {
-        telegramBotToken: process.env.TELEGRAM_BOT_TOKEN || '',
+        telegramBotToken: process.env.TELEGRAM_BOT_TOKEN || undefined,
+        feishuAppId: process.env.FEISHU_APP_ID || undefined,
+        feishuAppSecret: process.env.FEISHU_APP_SECRET || undefined,
+        feishuEncryptKey: process.env.FEISHU_ENCRYPT_KEY,
+        feishuVerificationToken: process.env.FEISHU_VERIFICATION_TOKEN,
+        feishuWebhookPort: parseInt(process.env.FEISHU_WEBHOOK_PORT || '3001', 10),
         opencodeServerUrl: process.env.OPENCODE_SERVER_URL || 'http://localhost:3000',
         tunnelUrl: process.env.TUNNEL_URL || '',
         sessionIdleTimeoutMs: parseInt(process.env.SESSION_IDLE_TIMEOUT_MS || '1800000', 10),

package/dist/feishu/bot.js

@@ -0,0 +1,350 @@
+// Feishu bot implementation for OpenCode Remote Control
+import express from 'express';
+import * as lark from '@larksuiteoapi/node-sdk';
+import { initSessionManager, getOrCreateSession } from '../core/session.js';
+import { splitMessage } from '../core/notifications.js';
+import { EMOJI } from '../core/types.js';
+import { initOpenCode, createSession, sendMessage, checkConnection } from '../opencode/client.js';
+let feishuClient = null;
+let config = null;
+let openCodeSessions = null;
+// Map Feishu event to shared MessageContext
+// Prefix threadId with 'feishu:' to avoid collision with Telegram sessions
+function feishuEventToContext(event) {
+    return {
+        platform: 'feishu',
+        threadId: `feishu:${event.message.chat_id}`,
+        userId: event.sender?.sender_id?.user_id || 'unknown',
+        messageId: event.message.message_id,
+    };
+}
+// BotAdapter implementation for Feishu
+function createFeishuAdapter(client) {
+    return {
+        async reply(threadId, text) {
+            // Extract chat_id from threadId (format: feishu:chat_id)
+            const chatId = threadId.replace('feishu:', '');
+            try {
+                const result = await client.im.message.create({
+                    params: { receive_id_type: 'chat_id' },
+                    data: {
+                        receive_id: chatId,
+                        msg_type: 'text',
+                        content: JSON.stringify({ text }),
+                    },
+                });
+                return result.data?.message_id || '';
+            }
+            catch (error) {
+                console.error('Failed to send Feishu message:', error);
+                throw error;
+            }
+        },
+        async sendTypingIndicator(threadId) {
+            // Feishu doesn't have typing indicator
+            // Could optionally send a "thinking..." message, but we'll skip for now
+        },
+        async deleteMessage(threadId, messageId) {
+            if (!messageId)
+                return;
+            try {
+                await client.im.message.delete({
+                    path: { message_id: messageId },
+                });
+            }
+            catch (error) {
+                // Ignore delete errors - not critical
+                console.warn('Failed to delete Feishu message:', error);
+            }
+        },
+    };
+}
+// Command handler (mirrors Telegram bot structure)
+async function handleCommand(adapter, ctx, text) {
+    const session = getOrCreateSession(ctx.threadId, 'feishu');
+    const parts = text.split(/\s+/);
+    const command = parts[0].toLowerCase();
+    switch (command) {
+        case '/start':
+        case '/help':
+            await adapter.reply(ctx.threadId, `🚀 OpenCode Remote Control ready
+
+💬 Send me a prompt to start coding
+/help — see all commands
+/status — check OpenCode connection
+
+Commands:
+/start — Start bot
+/status — Check connection
+/reset — Reset session
+/approve — Approve pending changes
+/reject — Reject pending changes
+/diff — See full diff
+/files — List changed files
+/retry — Retry connection
+
+💬 Anything else is treated as a prompt for OpenCode!`);
+            break;
+        case '/approve': {
+            const pending = session.pendingApprovals[0];
+            if (!pending) {
+                await adapter.reply(ctx.threadId, '🤷 Nothing to approve right now');
+                return;
+            }
+            // TODO: Actually apply changes via OpenCode SDK
+            await adapter.reply(ctx.threadId, '✅ Approved — changes applied');
+            break;
+        }
+        case '/reject': {
+            const pending = session.pendingApprovals[0];
+            if (!pending) {
+                await adapter.reply(ctx.threadId, '🤷 Nothing to reject right now');
+                return;
+            }
+            session.pendingApprovals.shift();
+            await adapter.reply(ctx.threadId, '❌ Rejected — changes discarded');
+            break;
+        }
+        case '/diff': {
+            const pending = session.pendingApprovals[0];
+            if (!pending || !pending.files?.length) {
+                await adapter.reply(ctx.threadId, '📄 No pending changes to show');
+                return;
+            }
+            // TODO: Get actual diff from OpenCode SDK
+            const diffPreview = pending.files.map(f => `--- a/${f.path}\n+++ b/${f.path}\n@@ changes +${f.additions} -${f.deletions} @@`).join('\n');
+            const messages = splitMessage(`\`\`\`diff\n${diffPreview}\n\`\`\``);
+            for (const msg of messages) {
+                await adapter.reply(ctx.threadId, msg);
+            }
+            break;
+        }
+        case '/files': {
+            const pending = session.pendingApprovals[0];
+            if (!pending || !pending.files?.length) {
+                await adapter.reply(ctx.threadId, '📄 No files changed in this session');
+                return;
+            }
+            const fileList = pending.files.map(f => `• ${f.path} (+${f.additions}, -${f.deletions})`).join('\n');
+            await adapter.reply(ctx.threadId, `📄 Changed files:\n${fileList}`);
+            break;
+        }
+        case '/status': {
+            const openCodeConnected = await checkConnection();
+            const openCodeSession = openCodeSessions?.get(ctx.threadId);
+            const idleSeconds = Math.round((Date.now() - session.lastActivity) / 1000);
+            const pendingCount = session.pendingApprovals.length;
+            await adapter.reply(ctx.threadId, `${openCodeConnected ? '✅' : '❌'} Connected\n\n💬 Session: ${openCodeSession?.sessionId?.slice(0, 8) || 'none'}\n⏰ Idle: ${idleSeconds}s\n📝 Pending approvals: ${pendingCount}`);
+            break;
+        }
+        case '/reset':
+            session.pendingApprovals = [];
+            session.opencodeSessionId = undefined;
+            // Clear OpenCode session
+            openCodeSessions?.delete(ctx.threadId);
+            await adapter.reply(ctx.threadId, '🔄 Session reset. Start fresh!');
+            break;
+        case '/retry': {
+            const connected = await checkConnection();
+            if (connected) {
+                await adapter.reply(ctx.threadId, '✅ OpenCode is now online!');
+            }
+            else {
+                await adapter.reply(ctx.threadId, '❌ Still offline. Is OpenCode running?');
+            }
+            break;
+        }
+        default:
+            await adapter.reply(ctx.threadId, `${EMOJI.WARNING} Unknown command: ${command}\n\nTry /help`);
+    }
+}
+// Handle incoming message from Feishu
+async function handleMessage(adapter, ctx, text) {
+    const session = getOrCreateSession(ctx.threadId, 'feishu');
+    // Check if it's a command
+    if (text.startsWith('/')) {
+        await handleCommand(adapter, ctx, text);
+        return;
+    }
+    // Check OpenCode connection
+    const connected = await checkConnection();
+    if (!connected) {
+        await adapter.reply(ctx.threadId, `❌ OpenCode is offline
+
+Cannot connect to OpenCode server.
+
+🔄 /retry — check again`);
+        return;
+    }
+    // Send typing indicator (Feishu style)
+    const typingMsg = await adapter.reply(ctx.threadId, '⏳');
+    // Get or create OpenCode session
+    let openCodeSession = openCodeSessions?.get(ctx.threadId);
+    if (!openCodeSession) {
+        const newSession = await createSession(ctx.threadId, `Feishu chat ${ctx.threadId}`);
+        if (!newSession) {
+            await adapter.reply(ctx.threadId, '❌ Failed to create OpenCode session');
+            return;
+        }
+        openCodeSession = newSession;
+        openCodeSessions.set(ctx.threadId, openCodeSession);
+        session.opencodeSessionId = openCodeSession.sessionId;
+        // Share the session URL (only if sharing is enabled)
+        if (openCodeSession.shareUrl) {
+            await adapter.reply(ctx.threadId, `🔗 Session: ${openCodeSession.shareUrl}`);
+        }
+    }
+    try {
+        const response = await sendMessage(openCodeSession, text);
+        // Delete typing indicator
+        if (adapter.deleteMessage && typingMsg) {
+            await adapter.deleteMessage(ctx.threadId, typingMsg);
+        }
+        // Split long messages
+        const messages = splitMessage(response);
+        for (const msg of messages) {
+            await adapter.reply(ctx.threadId, msg);
+        }
+    }
+    catch (error) {
+        console.error('Error sending message:', error);
+        await adapter.reply(ctx.threadId, `❌ Error: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}
+// Rate limiting (in-memory, per-chat)
+const rateLimitMap = new Map();
+const RATE_LIMIT = 100; // messages per minute per chat
+const RATE_WINDOW = 60000; // 1 minute
+function checkRateLimit(chatId) {
+    const now = Date.now();
+    const entry = rateLimitMap.get(chatId);
+    if (!entry || now > entry.resetTime) {
+        rateLimitMap.set(chatId, { count: 1, resetTime: now + RATE_WINDOW });
+        return true;
+    }
+    if (entry.count >= RATE_LIMIT) {
+        return false;
+    }
+    entry.count++;
+    return true;
+}
+// Start Feishu bot
+export async function startFeishuBot(botConfig) {
+    config = botConfig;
+    if (!config.feishuAppId || !config.feishuAppSecret) {
+        throw new Error('Feishu credentials not configured');
+    }
+    // Initialize Feishu client
+    feishuClient = new lark.Client({
+        appId: config.feishuAppId,
+        appSecret: config.feishuAppSecret,
+        // Uses feishu.cn domain by default (for China users)
+        // For international Lark, add: domain: lark.Domain.Lark
+    });
+    // Initialize session manager
+    initSessionManager(config);
+    // Initialize OpenCode sessions map
+    openCodeSessions = new Map();
+    // Initialize OpenCode
+    console.log('🔧 Initializing OpenCode...');
+    try {
+        await initOpenCode();
+        console.log('✅ OpenCode ready');
+    }
+    catch (error) {
+        console.error('❌ Failed to initialize OpenCode:', error);
+        console.log('Make sure OpenCode is running');
+    }
+    // Create adapter
+    const adapter = createFeishuAdapter(feishuClient);
+    // Create Express server for webhook
+    const app = express();
+    app.use(express.json());
+    const webhookPath = '/feishu/webhook';
+    const port = config.feishuWebhookPort || 3001;
+    // Webhook endpoint for Feishu events
+    app.post(webhookPath, async (req, res) => {
+        const event = req.body;
+        // Handle URL verification challenge (required for Feishu bot setup)
+        if (event.type === 'url_verification') {
+            res.json({ challenge: event.challenge });
+            return;
+        }
+        // Validate event structure
+        if (!event.header?.event_type) {
+            res.status(400).json({ code: -1, msg: 'Invalid event structure' });
+            return;
+        }
+        // Handle message events
+        if (event.header.event_type === 'im.message.receive_v1') {
+            try {
+                // Validate event data
+                if (!event.event?.message) {
+                    res.status(400).json({ code: -1, msg: 'Missing message data' });
+                    return;
+                }
+                const ctx = feishuEventToContext(event.event);
+                const chatId = event.event.message.chat_id;
+                // Rate limiting
+                if (!checkRateLimit(chatId)) {
+                    console.warn(`Rate limit exceeded for chat: ${chatId}`);
+                    res.status(429).json({ code: -1, msg: 'Rate limit exceeded' });
+                    return;
+                }
+                // Parse message content
+                let text = '';
+                try {
+                    const content = JSON.parse(event.event.message.content);
+                    text = content.text || '';
+                }
+                catch {
+                    // If not JSON, try to use raw content
+                    text = event.event.message.content || '';
+                }
+                // Skip empty messages
+                if (!text.trim()) {
+                    res.json({ code: 0 });
+                    return;
+                }
+                // Handle the message
+                await handleMessage(adapter, ctx, text);
+                res.json({ code: 0 });
+            }
+            catch (error) {
+                console.error('Feishu webhook error:', error);
+                res.status(500).json({ code: -1, msg: 'Internal error' });
+            }
+            return;
+        }
+        // Unknown event type - acknowledge but ignore
+        console.log(`Received Feishu event: ${event.header.event_type}`);
+        res.json({ code: 0 });
+    });
+    // Health check endpoint
+    app.get('/health', (_req, res) => {
+        res.json({ status: 'ok', platform: 'feishu' });
+    });
+    // Start server
+    return new Promise((resolve, reject) => {
+        const server = app.listen(port, () => {
+            console.log(`🚀 Feishu webhook listening on port ${port}`);
+            console.log(`📡 Webhook URL: http://localhost:${port}${webhookPath}`);
+            console.log('\n📝 Setup instructions:');
+            console.log('  1. Use ngrok or cloudflared to expose this endpoint:');
+            console.log('     ngrok http ' + port);
+            console.log('  2. Configure the webhook URL in Feishu admin console');
+            console.log('  3. Subscribe to "im.message.receive_v1" event');
+        });
+        server.on('error', (err) => {
+            reject(err);
+        });
+        // Handle graceful shutdown
+        process.on('SIGINT', () => {
+            console.log('\n🛑 Shutting down Feishu bot...');
+            server.close(() => {
+                console.log('Feishu bot stopped');
+                resolve();
+            });
+        });
+    });
+}

package/dist/opencode/client.js

@@ -12,7 +12,7 @@ export async function initOpenCode() {
     console.log('✅ OpenCode server ready');
     return opencodeInstance;
 }
-export async function createSession(threadId, title = `Remote control session`) {
+export async function createSession(_threadId, title = `Remote control session`) {
     const opencode = await initOpenCode();
     try {
         const createResult = await opencode.client.session.create({
@@ -24,14 +24,17 @@ export async function createSession(threadId, title = `Remote control session`)
         }
         const sessionId = createResult.data.id;
         console.log(`✅ Created OpenCode session: ${sessionId}`);
-        // Share the session to get a URL
+        // Note: Sharing is disabled by default for privacy
+        // Set SHARE_SESSIONS=true in .env to enable public sharing
         let shareUrl;
-        const shareResult = await opencode.client.session.share({
-            path: { id: sessionId }
-        });
-        if (!shareResult.error && shareResult.data?.share?.url) {
-            shareUrl = shareResult.data.share.url;
-            console.log(`🔗 Session shared: ${shareUrl}`);
+        if (process.env.SHARE_SESSIONS === 'true') {
+            const shareResult = await opencode.client.session.share({
+                path: { id: sessionId }
+            });
+            if (!shareResult.error && shareResult.data?.share?.url) {
+                shareUrl = shareResult.data.share.url;
+                console.log(`🔗 Session shared: ${shareUrl}`);
+            }
         }
         return {
             sessionId,

package/dist/telegram/bot.js

@@ -153,7 +153,7 @@ Cannot connect to OpenCode server.
         // Get or create OpenCode session
         let openCodeSession = openCodeSessions.get(threadId);
         if (!openCodeSession) {
-            await ctx.reply('⏳ Creating session...');
+            // Keep typing indicator while creating session
             const newSession = await createSession(threadId, `Telegram thread ${threadId}`);
             if (!newSession) {
                 await ctx.reply('❌ Failed to create OpenCode session');
@@ -162,13 +162,13 @@ Cannot connect to OpenCode server.
             openCodeSession = newSession;
             openCodeSessions.set(threadId, openCodeSession);
             session.opencodeSessionId = openCodeSession.sessionId;
-            // Share the session URL
+            // Share the session URL (only if sharing is enabled)
             if (openCodeSession.shareUrl) {
                 await ctx.reply(`🔗 Session: ${openCodeSession.shareUrl}`);
             }
         }
-        // Send prompt to OpenCode
-        await ctx.reply('⏳ Thinking...');
+        // Refresh typing indicator before sending prompt
+        await ctx.api.sendChatAction(ctx.chat.id, 'typing');
         try {
             const response = await sendMessage(openCodeSession, text);
             // Split long messages

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "opencode-remote-control",
-  "version": "0.1.3",
-  "description": "Control OpenCode from anywhere via Telegram",
+  "version": "0.2.0",
+  "description": "Control OpenCode from anywhere via Telegram or Feishu",
   "type": "module",
   "bin": {
     "opencode-remote": "./dist/cli.js"
@@ -20,7 +20,10 @@
     "README.md"
   ],
   "dependencies": {
+    "@larksuiteoapi/node-sdk": "^1.59.0",
     "@opencode-ai/sdk": "^1.2.27",
+    "@types/express": "^5.0.6",
+    "express": "^5.2.1",
     "grammy": "^1.30.0"
   },
   "devDependencies": {
@@ -38,6 +41,8 @@
   "keywords": [
     "opencode",
     "telegram",
+    "feishu",
+    "lark",
     "remote-control",
     "ai",
     "coding"