opencode-remote-control 0.1.0

package/README.md

@@ -0,0 +1,106 @@
+# OpenCode Remote Control
+
+[中文文档](./README_CN.md)
+
+Control OpenCode from anywhere via Telegram.
+
+## Installation
+
+```bash
+# Install globally with npm, pnpm, or bun
+npm install -g opencode-remote-control
+# or
+pnpm install -g opencode-remote-control
+# or
+bun install -g opencode-remote-control
+
+# Run (will prompt for token on first run)
+opencode-remote
+```
+
+### Install from Source
+
+```bash
+git clone https://github.com/ceociocto/opencode-remote-control.git
+cd opencode-remote-control
+bun install
+bun run build
+node dist/cli.js
+```
+
+## Setup
+
+On first run, you'll be prompted for a Telegram bot token:
+
+1. Open Telegram, search **@BotFather**
+2. Send `/newbot` and follow instructions
+3. Paste the token when prompted
+
+Token is saved to `~/.opencode-remote/.env`
+
+## Commands
+
+**CLI:**
+```
+opencode-remote         # Start the bot
+opencode-remote config  # Reconfigure token
+opencode-remote help    # Show help
+```
+
+**Telegram:**
+| Command | Description |
+|--------|-------------|
+| `/start` | Start the bot |
+| `/help` | Show all commands |
+| `/status` | Check connection status |
+| `/approve` | Approve pending changes |
+| `/reject` | Reject pending changes |
+| `/diff` | View pending diff |
+| `/files` | List changed files |
+| `/reset` | Reset session |
+
+## How It Works
+
+```
+┌─────────────────┐                    ┌──────────────────┐
+│  Telegram App   │                    │  Telegram Server │
+│   (Mobile)      │◀──── Messages ────▶│     (Cloud)      │
+└─────────────────┘                    └────────┬─────────┘
+                                                │
+                     ┌──────── Polling ─────────┘
+                     ▼
+┌─────────────────────────────────────────────────────────┐
+│              Bot Service (Local Machine)                │
+│  ┌─────────────┐      ┌──────────────┐                  │
+│  │ Telegram    │      │   Session    │                  │
+│  │ Bot         │─────▶│   Manager    │                  │
+│  └─────────────┘      └──────┬───────┘                  │
+│                              │                          │
+│                              ▼                          │
+│                    ┌──────────────────┐                 │
+│                    │   OpenCode SDK   │                 │
+│                    └──────────────────┘                 │
+└─────────────────────────────────────────────────────────┘
+```
+
+The bot uses **Polling Mode** to fetch messages from Telegram servers, requiring no tunnel or public IP configuration.
+
+## Requirements
+
+- Node.js >= 18.0.0
+- [OpenCode](https://github.com/opencode-ai/opencode) installed
+- Telegram account
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add some amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+## License
+
+MIT

package/dist/cli.js

@@ -0,0 +1,131 @@
+#!/usr/bin/env node
+// OpenCode Remote Control - CLI entry point
+import { existsSync, writeFileSync, readFileSync, mkdirSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+import { startBot } from './telegram/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
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+`);
+}
+function printHelp() {
+    console.log(`
+Usage: opencode-remote [command]
+
+Commands:
+  start     Start the bot (default)
+  config    Configure Telegram bot token
+  help      Show this help message
+
+Examples:
+  opencode-remote           # Start the bot
+  opencode-remote start     # Start the bot
+  opencode-remote config    # Configure token
+`);
+}
+async function promptToken() {
+    console.log('\n📝 Setup required: Telegram Bot Token');
+    console.log('\nHow to get a token:');
+    console.log('  1. Open Telegram');
+    console.log('  2. Search @BotFather');
+    console.log('  3. Send /newbot and follow instructions');
+    console.log('  4. Copy the token you receive');
+    console.log('');
+    process.stdout.write('Enter your bot token: ');
+    // Read from stdin
+    const token = await new Promise((resolve) => {
+        process.stdin.setEncoding('utf8');
+        process.stdin.once('data', (chunk) => {
+            resolve(chunk.toString().trim());
+        });
+    });
+    return token;
+}
+async function getConfig() {
+    // Check environment variable first
+    if (process.env.TELEGRAM_BOT_TOKEN) {
+        return process.env.TELEGRAM_BOT_TOKEN;
+    }
+    // Check config file
+    if (existsSync(CONFIG_FILE)) {
+        const content = readFileSync(CONFIG_FILE, 'utf-8');
+        const match = content.match(/TELEGRAM_BOT_TOKEN=(.+)/);
+        if (match) {
+            return match[1].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) {
+            return match[1].trim();
+        }
+    }
+    return null;
+}
+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`);
+    console.log(`\n✅ Token saved to ${CONFIG_FILE}`);
+}
+async function runConfig() {
+    printBanner();
+    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.');
+}
+async function runStart() {
+    printBanner();
+    const token = await getConfig();
+    if (!token) {
+        console.log('⚠️  No bot token configured.\n');
+        await runConfig();
+        return;
+    }
+    // Set token in environment
+    process.env.TELEGRAM_BOT_TOKEN = token;
+    console.log('🚀 Starting bot...\n');
+    try {
+        await startBot();
+    }
+    catch (error) {
+        console.error('Failed to start:', error);
+        process.exit(1);
+    }
+}
+// Main CLI
+const args = process.argv.slice(2);
+const command = args[0] || 'start';
+switch (command) {
+    case 'start':
+        runStart();
+        break;
+    case 'config':
+        runConfig();
+        break;
+    case 'help':
+    case '--help':
+    case '-h':
+        printBanner();
+        printHelp();
+        break;
+    default:
+        console.log(`Unknown command: ${command}`);
+        printHelp();
+        process.exit(1);
+}

package/dist/core/approval.js

@@ -0,0 +1,95 @@
+// Approval workflow for OpenCode Remote Control
+import { loadConfig } from './types.js';
+const approvalCallbacks = new Map();
+export function createApprovalRequest(session, type, data) {
+    const config = loadConfig();
+    const now = Date.now();
+    const request = {
+        id: crypto.randomUUID(),
+        type,
+        description: data.description,
+        files: data.files,
+        command: data.command,
+        createdAt: now,
+        expiresAt: now + config.approvalTimeoutMs,
+    };
+    // Add to session's pending approvals
+    session.pendingApprovals.push(request);
+    return request;
+}
+export function getPendingApproval(session, requestId) {
+    if (requestId) {
+        return session.pendingApprovals.find(r => r.id === requestId);
+    }
+    return session.pendingApprovals[0]; // Return first pending
+}
+export function resolveApproval(session, requestId, approved) {
+    const index = session.pendingApprovals.findIndex(r => r.id === requestId);
+    if (index === -1) {
+        return { success: false, error: 'Approval request not found' };
+    }
+    const request = session.pendingApprovals[index];
+    // Check if expired
+    if (Date.now() > request.expiresAt) {
+        session.pendingApprovals.splice(index, 1);
+        return { success: false, error: 'Approval request expired', request };
+    }
+    // Remove from pending
+    session.pendingApprovals.splice(index, 1);
+    // Resolve the promise if there's a callback
+    const callback = approvalCallbacks.get(requestId);
+    if (callback) {
+        callback.resolve(approved);
+        approvalCallbacks.delete(requestId);
+    }
+    return { success: true, request };
+}
+export function waitForApproval(request) {
+    return new Promise((resolve, reject) => {
+        approvalCallbacks.set(request.id, { resolve, reject });
+        // Auto-reject on timeout
+        const timeUntilExpiry = request.expiresAt - Date.now();
+        setTimeout(() => {
+            const callback = approvalCallbacks.get(request.id);
+            if (callback) {
+                approvalCallbacks.delete(request.id);
+                callback.resolve(false); // Auto-reject
+            }
+        }, timeUntilExpiry);
+    });
+}
+export function cancelAllApprovals(session) {
+    for (const request of session.pendingApprovals) {
+        const callback = approvalCallbacks.get(request.id);
+        if (callback) {
+            approvalCallbacks.delete(request.id);
+            callback.reject(new Error('Session ended'));
+        }
+    }
+    session.pendingApprovals = [];
+}
+// Format approval request for display
+export function formatApprovalMessage(request) {
+    const lines = [];
+    if (request.type === 'file_edit') {
+        lines.push('📝 Approval needed: Edit files');
+        lines.push('');
+        lines.push('📄 Changes:');
+        if (request.files) {
+            for (const file of request.files) {
+                lines.push(`• ${file.path} (+${file.additions}, -${file.deletions})`);
+            }
+        }
+    }
+    else {
+        lines.push('📝 Approval needed: Run command');
+        lines.push('');
+        lines.push(`🔧 \`${request.command}\``);
+    }
+    lines.push('');
+    lines.push('/approve — allow changes');
+    lines.push('/reject — deny changes');
+    lines.push('/diff — see what will change first');
+    lines.push(`⏱️ Expires in ${Math.round((request.expiresAt - Date.now()) / 60000)} min (auto-reject)`);
+    return lines.join('\n');
+}

package/dist/core/handler-common.js

@@ -0,0 +1,116 @@
+// Shared handler logic for OpenCode Remote Control
+import { getOrCreateSession } from './session.js';
+import { createApprovalRequest, waitForApproval, formatApprovalMessage } from './approval.js';
+import { TEMPLATES, splitMessage } from './notifications.js';
+export function createHandler(deps) {
+    return {
+        // Handle incoming message from user
+        async handleMessage(ctx, text) {
+            const session = getOrCreateSession(ctx.threadId, ctx.platform);
+            // Check if it's a command
+            if (text.startsWith('/')) {
+                await this.handleCommand(ctx, text, session);
+                return;
+            }
+            // It's a prompt - send to OpenCode
+            await deps.sendTyping(ctx.threadId);
+            // TODO: Actually send to OpenCode SDK
+            // For now, echo back
+            await deps.sendMessage(ctx.threadId, TEMPLATES.thinking());
+            // Simulate response
+            setTimeout(async () => {
+                await deps.sendMessage(ctx.threadId, TEMPLATES.taskCompleted([
+                    { path: 'src/example.ts', additions: 10, deletions: 2 }
+                ]));
+            }, 1000);
+        },
+        // Handle commands
+        async handleCommand(ctx, text, session) {
+            const parts = text.split(/\s+/);
+            const command = parts[0].toLowerCase();
+            switch (command) {
+                case '/start':
+                case '/help':
+                    await deps.sendMessage(ctx.threadId, TEMPLATES.botStarted());
+                    break;
+                case '/approve':
+                    await this.handleApprove(ctx, session);
+                    break;
+                case '/reject':
+                    await this.handleReject(ctx, session);
+                    break;
+                case '/diff':
+                    await this.handleDiff(ctx, session);
+                    break;
+                case '/files':
+                    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`);
+                    break;
+                case '/reset':
+                    session.pendingApprovals = [];
+                    session.opencodeSessionId = undefined;
+                    await deps.sendMessage(ctx.threadId, '🔄 Session reset. Start fresh!');
+                    break;
+                default:
+                    await deps.sendMessage(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');
+                return;
+            }
+            // Resolve the approval
+            // TODO: Actually apply changes via OpenCode SDK
+            await deps.sendMessage(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');
+                return;
+            }
+            session.pendingApprovals.shift();
+            await deps.sendMessage(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');
+                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);
+            }
+        },
+        // 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');
+                return;
+            }
+            const fileList = pending.files.map(f => `• ${f.path} (+${f.additions}, -${f.deletions})`).join('\n');
+            await deps.sendMessage(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);
+            // Wait for user response
+            return waitForApproval(request);
+        }
+    };
+}
+// Re-export emoji for use in handlers
+import { EMOJI } from './types.js';

package/dist/core/notifications.js

@@ -0,0 +1,134 @@
+// Notification formatting for OpenCode Remote Control
+import { EMOJI } from './types.js';
+export function formatNotification(options) {
+    const lines = [];
+    // Status indicator
+    switch (options.type) {
+        case 'success':
+            lines.push(`${EMOJI.SUCCESS} ${options.title || 'Done'}`);
+            break;
+        case 'error':
+            lines.push(`${EMOJI.ERROR} ${options.title || 'Error'}`);
+            break;
+        case 'loading':
+            lines.push(`${EMOJI.LOADING} ${options.title || 'Thinking...'}`);
+            break;
+        case 'input_needed':
+            lines.push(`${EMOJI.QUESTION} ${options.title || 'Question'}`);
+            break;
+        case 'expired':
+            lines.push(`${EMOJI.EXPIRED} ${options.title || 'Session expired'}`);
+            break;
+        case 'started':
+            lines.push(`${EMOJI.START} ${options.title || 'Ready'}`);
+            break;
+    }
+    // Add blank line if we have more content
+    if (options.details || options.files || options.actions) {
+        lines.push('');
+    }
+    // Files changed
+    if (options.files && options.files.length > 0) {
+        lines.push(`📄 ${options.files.length} files changed:`);
+        for (const file of options.files.slice(0, 5)) {
+            lines.push(`• ${file.path} (+${file.additions}, -${file.deletions})`);
+        }
+        if (options.files.length > 5) {
+            lines.push(`• ... and ${options.files.length - 5} more`);
+        }
+    }
+    // Details
+    if (options.details) {
+        lines.push(options.details);
+    }
+    // Actions
+    if (options.actions && options.actions.length > 0) {
+        lines.push('');
+        lines.push(options.actions.join(' • '));
+    }
+    return lines.join('\n');
+}
+// Pre-built message templates
+export const TEMPLATES = {
+    botStarted: () => formatNotification({
+        type: 'started',
+        title: 'OpenCode Remote Control ready',
+        actions: ['💬 Send a prompt to start', '/help — commands', '/status — connection']
+    }),
+    sessionExpired: () => formatNotification({
+        type: 'expired',
+        title: 'Session expired (30 min idle)',
+        actions: ['💬 Send new message to start fresh']
+    }),
+    taskCompleted: (files) => formatNotification({
+        type: 'success',
+        files,
+        actions: ['💬 Reply to continue', '/files — details']
+    }),
+    taskFailed: (error) => formatNotification({
+        type: 'error',
+        title: error.slice(0, 50),
+        details: 'The task failed. OpenCode is still running.',
+        actions: ['💬 Try rephrasing', '/reset — start fresh']
+    }),
+    needsInput: (question, options) => formatNotification({
+        type: 'input_needed',
+        title: question,
+        details: options ? options.map((o, i) => `${i + 1}. ${o}`).join('\n') : undefined,
+        actions: options ? ['Reply with number'] : undefined
+    }),
+    openCodeOffline: () => formatNotification({
+        type: 'error',
+        title: 'OpenCode is offline',
+        details: 'Cannot connect to OpenCode server.',
+        actions: ['🔄 /retry — check again', '/status — diagnostics']
+    }),
+    thinking: () => formatNotification({
+        type: 'loading',
+        title: 'Thinking...'
+    }),
+    approved: () => formatNotification({
+        type: 'success',
+        title: 'Approved — changes applied'
+    }),
+    rejected: () => formatNotification({
+        type: 'success',
+        title: 'Rejected — changes discarded'
+    }),
+    approvalTimeout: () => formatNotification({
+        type: 'error',
+        title: 'Approval timed out (5 min)',
+        details: 'Changes were automatically rejected.',
+    }),
+};
+// Split message for Telegram's 4096 char limit
+export function splitMessage(text, maxLength = 4000) {
+    if (text.length <= maxLength) {
+        return [text];
+    }
+    const messages = [];
+    let remaining = text;
+    while (remaining.length > 0) {
+        if (remaining.length <= maxLength) {
+            messages.push(remaining);
+            break;
+        }
+        // Find a good break point
+        let breakPoint = remaining.lastIndexOf('\n', maxLength);
+        if (breakPoint < maxLength * 0.5) {
+            breakPoint = remaining.lastIndexOf(' ', maxLength);
+        }
+        if (breakPoint < maxLength * 0.5) {
+            breakPoint = maxLength;
+        }
+        messages.push(remaining.slice(0, breakPoint));
+        remaining = remaining.slice(breakPoint).trim();
+    }
+    // Add continuation indicator
+    if (messages.length > 1) {
+        for (let i = 0; i < messages.length - 1; i++) {
+            messages[i] += '\n\n... (continued)';
+        }
+    }
+    return messages;
+}

package/dist/core/session.js

@@ -0,0 +1,61 @@
+// Session management for OpenCode Remote Control
+import { loadConfig } from './types.js';
+const sessions = new Map();
+let cleanupTimer = null;
+export function initSessionManager(config = loadConfig()) {
+    // Start cleanup timer
+    if (cleanupTimer) {
+        clearInterval(cleanupTimer);
+    }
+    cleanupTimer = setInterval(() => {
+        const now = Date.now();
+        for (const [threadId, session] of sessions.entries()) {
+            if (now - session.lastActivity > config.sessionIdleTimeoutMs) {
+                sessions.delete(threadId);
+                console.log(`Session expired: ${threadId}`);
+            }
+        }
+    }, config.cleanupIntervalMs);
+    console.log(`Session manager initialized (cleanup every ${config.cleanupIntervalMs / 1000}s)`);
+}
+export function getOrCreateSession(threadId, platform) {
+    const existing = sessions.get(threadId);
+    if (existing) {
+        existing.lastActivity = Date.now();
+        return existing;
+    }
+    const newSession = {
+        id: crypto.randomUUID(),
+        threadId,
+        platform,
+        createdAt: Date.now(),
+        lastActivity: Date.now(),
+        pendingApprovals: [],
+    };
+    sessions.set(threadId, newSession);
+    console.log(`Session created: ${threadId}`);
+    return newSession;
+}
+export function getSession(threadId) {
+    return sessions.get(threadId);
+}
+export function updateSession(threadId, updates) {
+    const session = sessions.get(threadId);
+    if (!session)
+        return undefined;
+    Object.assign(session, updates, { lastActivity: Date.now() });
+    return session;
+}
+export function deleteSession(threadId) {
+    return sessions.delete(threadId);
+}
+export function getAllSessions() {
+    return Array.from(sessions.values());
+}
+export function getSessionCount() {
+    return sessions.size;
+}
+// Export sessions map for testing
+export function _getSessionsMap() {
+    return sessions;
+}

package/dist/core/types.js

@@ -0,0 +1,25 @@
+// Core types for OpenCode Remote Control
+// Message templates - emoji vocabulary
+export const EMOJI = {
+    SUCCESS: '✅',
+    ERROR: '❌',
+    LOADING: '⏳',
+    THINKING: '🤔',
+    APPROVAL: '📝',
+    FILES: '📄',
+    CODE: '🔧',
+    START: '🚀',
+    EXPIRED: '💤',
+    WARNING: '⚠️',
+    QUESTION: '💬',
+};
+export function loadConfig() {
+    return {
+        telegramBotToken: process.env.TELEGRAM_BOT_TOKEN || '',
+        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),
+    };
+}

package/dist/index.js

@@ -0,0 +1,11 @@
+// OpenCode Remote Control - Main entry point
+import { startBot } from './telegram/bot.js';
+console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+console.log('  OpenCode Remote Control');
+console.log('  Control OpenCode from Telegram or Feishu');
+console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+// Start the bot
+startBot().catch((err) => {
+    console.error('Failed to start bot:', err);
+    process.exit(1);
+});

package/dist/opencode/client.js

@@ -0,0 +1,118 @@
+// OpenCode SDK client for remote control
+import { createOpencode } from '@opencode-ai/sdk';
+let opencodeInstance = null;
+export async function initOpenCode() {
+    if (opencodeInstance) {
+        return opencodeInstance;
+    }
+    console.log('🚀 Starting OpenCode server...');
+    opencodeInstance = await createOpencode({
+        port: 0, // Don't start HTTP server
+    });
+    console.log('✅ OpenCode server ready');
+    return opencodeInstance;
+}
+export async function createSession(threadId, title = `Remote control session`) {
+    const opencode = await initOpenCode();
+    try {
+        const createResult = await opencode.client.session.create({
+            body: { title },
+        });
+        if (createResult.error) {
+            console.error('Failed to create session:', createResult.error);
+            return null;
+        }
+        const sessionId = createResult.data.id;
+        console.log(`✅ Created OpenCode session: ${sessionId}`);
+        // Share the session to get a URL
+        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}`);
+        }
+        return {
+            sessionId,
+            client: opencode.client,
+            server: opencode.server,
+            shareUrl,
+        };
+    }
+    catch (error) {
+        console.error('Error creating session:', error);
+        return null;
+    }
+}
+export async function sendMessage(session, message) {
+    try {
+        console.log(`📝 Sending to OpenCode: ${message.slice(0, 50)}...`);
+        const result = await session.client.session.prompt({
+            path: { id: session.sessionId },
+            body: {
+                parts: [{ type: 'text', text: message }]
+            },
+        });
+        if (result.error) {
+            console.error('Failed to send message:', result.error);
+            return `❌ Error: ${result.error.message || 'Failed to send message'}`;
+        }
+        const response = result.data;
+        // Build response text from parts
+        const responseText = response.info?.content ||
+            response.parts
+                ?.filter((p) => p.type === 'text')
+                .map((p) => p.text)
+                .join('\n') ||
+            'I received your message but didn\'t have a response.';
+        console.log(`💬 Response: ${responseText.slice(0, 100)}...`);
+        return responseText;
+    }
+    catch (error) {
+        console.error('Error sending message:', error);
+        return `❌ Error: ${error instanceof Error ? error.message : 'Unknown error'}`;
+    }
+}
+export async function getSession(session) {
+    try {
+        const result = await session.client.session.get({
+            path: { id: session.sessionId }
+        });
+        if (result.error) {
+            return null;
+        }
+        return result.data;
+    }
+    catch {
+        return null;
+    }
+}
+export async function shareSession(session) {
+    try {
+        const result = await session.client.session.share({
+            path: { id: session.sessionId }
+        });
+        if (result.error || !result.data?.share?.url) {
+            return null;
+        }
+        return result.data.share.url;
+    }
+    catch {
+        return null;
+    }
+}
+// Get the global opencode instance
+export function getOpenCode() {
+    return opencodeInstance;
+}
+// Check if OpenCode is connected
+export async function checkConnection() {
+    try {
+        const opencode = await initOpenCode();
+        return !!opencode.client;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/telegram/bot.js

@@ -0,0 +1,210 @@
+// Telegram bot implementation for OpenCode Remote Control
+import { Bot } from 'grammy';
+import { loadConfig } from '../core/types.js';
+import { initSessionManager, getOrCreateSession } from '../core/session.js';
+import { splitMessage } from '../core/notifications.js';
+import { initOpenCode, createSession, sendMessage, checkConnection } from '../opencode/client.js';
+const config = loadConfig();
+// Create bot instance
+const bot = new Bot(config.telegramBotToken);
+// Initialize session manager
+initSessionManager(config);
+// Store OpenCode sessions by thread ID
+const openCodeSessions = new Map();
+// Start command
+bot.command('start', async (ctx) => {
+    await ctx.reply(`🚀 OpenCode Remote Control ready
+
+💬 Send me a prompt to start coding
+/help — see all commands
+/status — check OpenCode connection`);
+});
+// Help command
+bot.command('help', async (ctx) => {
+    await ctx.reply(`📖 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
+
+💬 Anything else is treated as a prompt for OpenCode!`);
+});
+// Status command
+bot.command('status', async (ctx) => {
+    const threadId = getThreadId(ctx);
+    const session = getOrCreateSession(threadId, 'telegram');
+    const openCodeSession = openCodeSessions.get(threadId);
+    // Check OpenCode connection
+    const connected = await checkConnection();
+    if (!connected) {
+        await ctx.reply(`❌ OpenCode is offline
+
+Cannot connect to OpenCode server.
+
+🔄 /retry — check again`);
+        return;
+    }
+    const idleSeconds = Math.round((Date.now() - session.lastActivity) / 1000);
+    const pendingCount = session.pendingApprovals.length;
+    await ctx.reply(`✅ Connected
+
+💬 Session: ${openCodeSession?.sessionId?.slice(0, 8) || 'none'}
+⏰ Idle: ${idleSeconds}s
+📝 Pending approvals: ${pendingCount}`);
+});
+// Approve command
+bot.command('approve', async (ctx) => {
+    const threadId = getThreadId(ctx);
+    const session = getOrCreateSession(threadId, 'telegram');
+    if (session.pendingApprovals.length === 0) {
+        await ctx.reply('🤷 Nothing to approve right now');
+        return;
+    }
+    // Remove first pending approval
+    session.pendingApprovals.shift();
+    await ctx.reply('✅ Approved — changes applied');
+});
+// Reject command
+bot.command('reject', async (ctx) => {
+    const threadId = getThreadId(ctx);
+    const session = getOrCreateSession(threadId, 'telegram');
+    if (session.pendingApprovals.length === 0) {
+        await ctx.reply('🤷 Nothing to reject right now');
+        return;
+    }
+    session.pendingApprovals.shift();
+    await ctx.reply('❌ Rejected — changes discarded');
+});
+// Reset command
+bot.command('reset', async (ctx) => {
+    const threadId = getThreadId(ctx);
+    const session = getOrCreateSession(threadId, 'telegram');
+    session.pendingApprovals = [];
+    session.opencodeSessionId = undefined;
+    // Clear OpenCode session
+    openCodeSessions.delete(threadId);
+    await ctx.reply('🔄 Session reset. Start fresh!');
+});
+// Diff command
+bot.command('diff', async (ctx) => {
+    const threadId = getThreadId(ctx);
+    const session = getOrCreateSession(threadId, 'telegram');
+    const pending = session.pendingApprovals[0];
+    if (!pending?.files?.length) {
+        await ctx.reply('📄 No pending changes to show');
+        return;
+    }
+    // Show file list with changes
+    const fileList = pending.files.map(f => `• ${f.path} (+${f.additions}, -${f.deletions})`).join('\n');
+    await ctx.reply(`📄 Pending changes:\n\n${fileList}\n\n💬 /approve or /reject`);
+});
+// Files command
+bot.command('files', async (ctx) => {
+    const threadId = getThreadId(ctx);
+    const session = getOrCreateSession(threadId, 'telegram');
+    const pending = session.pendingApprovals[0];
+    if (!pending?.files?.length) {
+        await ctx.reply('📄 No files changed in this session');
+        return;
+    }
+    const fileList = pending.files.map(f => `• ${f.path} (+${f.additions}, -${f.deletions})`).join('\n');
+    await ctx.reply(`📄 Changed files:\n\n${fileList}`);
+});
+// Retry command
+bot.command('retry', async (ctx) => {
+    const connected = await checkConnection();
+    if (connected) {
+        await ctx.reply('✅ OpenCode is now online!');
+    }
+    else {
+        await ctx.reply('❌ Still offline. Is OpenCode running?');
+    }
+});
+// Handle all other messages as prompts
+bot.on('message:text', async (ctx) => {
+    const text = ctx.message.text;
+    // Skip if it's a command (already handled)
+    if (text.startsWith('/'))
+        return;
+    const threadId = getThreadId(ctx);
+    // Send typing indicator
+    await ctx.api.sendChatAction(ctx.chat.id, 'typing');
+    // Get or create session
+    const session = getOrCreateSession(threadId, 'telegram');
+    // Check OpenCode connection
+    const connected = await checkConnection();
+    if (!connected) {
+        await ctx.reply(`❌ OpenCode is offline
+
+Cannot connect to OpenCode server.
+
+🔄 /retry — check again`);
+        return;
+    }
+    // Get or create OpenCode session
+    let openCodeSession = openCodeSessions.get(threadId);
+    if (!openCodeSession) {
+        await ctx.reply('⏳ Creating session...');
+        const newSession = await createSession(threadId, `Telegram thread ${threadId}`);
+        if (!newSession) {
+            await ctx.reply('❌ Failed to create OpenCode session');
+            return;
+        }
+        openCodeSession = newSession;
+        openCodeSessions.set(threadId, openCodeSession);
+        session.opencodeSessionId = openCodeSession.sessionId;
+        // Share the session URL
+        if (openCodeSession.shareUrl) {
+            await ctx.reply(`🔗 Session: ${openCodeSession.shareUrl}`);
+        }
+    }
+    // Send prompt to OpenCode
+    await ctx.reply('⏳ Thinking...');
+    try {
+        const response = await sendMessage(openCodeSession, text);
+        // Split long messages
+        const messages = splitMessage(response);
+        for (const msg of messages) {
+            await ctx.reply(msg);
+        }
+    }
+    catch (error) {
+        console.error('Error sending message:', error);
+        await ctx.reply(`❌ Error: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+});
+// Error handling
+bot.catch((err) => {
+    console.error('Bot error:', err);
+});
+// Helper to get thread ID
+function getThreadId(ctx) {
+    const chatId = ctx.chat?.id;
+    const threadId = ctx.message?.message_thread_id || ctx.message?.message_id;
+    return `${chatId}:${threadId}`;
+}
+export { bot };
+// Start bot function
+export async function startBot() {
+    if (!config.telegramBotToken) {
+        console.error('ERROR: TELEGRAM_BOT_TOKEN not set');
+        console.log('Get a token from @BotFather on Telegram');
+        process.exit(1);
+    }
+    // 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');
+    }
+    console.log('🚀 Starting Telegram bot...');
+    await bot.start();
+}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "opencode-remote-control",
+  "version": "0.1.0",
+  "description": "Control OpenCode from anywhere via Telegram",
+  "type": "module",
+  "bin": {
+    "opencode-remote": "./dist/cli.js"
+  },
+  "main": "./dist/index.js",
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "dev": "bun run --watch src/index.ts",
+    "start": "node dist/index.js",
+    "test": "bun test",
+    "test:watch": "bun test --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "dependencies": {
+    "@opencode-ai/sdk": "^1.2.27",
+    "grammy": "^1.30.0"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "@types/node": "^25.5.0",
+    "typescript": "^5.6.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ceociocto/opencode-remote-control.git"
+  },
+  "keywords": [
+    "opencode",
+    "telegram",
+    "remote-control",
+    "ai",
+    "coding"
+  ],
+  "author": "",
+  "license": "MIT"
+}