remote-opencode 1.0.1 → 1.0.3

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 RoundTable02
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -2,6 +2,10 @@
 
 > Control your AI coding assistant from anywhere — your phone, tablet, or another computer.
 
+<div align="center">
+<img width="1024" alt="Gemini_Generated_Image_47d5gq47d5gq47d5" src="https://github.com/user-attachments/assets/1defa11d-6195-4a9c-956b-4f87470f6393" />
+</div>
+
 **remote-opencode** is a Discord bot that bridges your local [OpenCode CLI](https://github.com/sst/opencode) to Discord, enabling you to interact with your AI coding assistant remotely. Perfect for developers who want to:
 
 - 📱 **Code from mobile** — Send coding tasks from your phone while away from your desk
@@ -38,6 +42,12 @@ The bot runs on your development machine alongside OpenCode. When you send a com
 - [Installation](#installation)
 - [Quick Start](#quick-start)
 - [Discord Bot Setup](#discord-bot-setup)
+  - [Step 1: Create Discord Application](#step-1-create-discord-application)
+  - [Step 2: Create Bot & Get Token](#step-2-create-bot--get-token)
+  - [Step 3: Enable Required Intents](#step-3-enable-required-intents)
+  - [Step 4: Configure Bot Permissions](#step-4-configure-bot-permissions)
+  - [Step 5: Get Your Server (Guild) ID](#step-5-get-your-server-guild-id)
+  - [Step 6: Invite Bot to Your Server](#step-6-invite-bot-to-your-server)
 - [CLI Commands](#cli-commands)
 - [Discord Slash Commands](#discord-slash-commands)
 - [Usage Workflow](#usage-workflow)
@@ -69,7 +79,7 @@ npx remote-opencode
 ### Install from source
 
 ```bash
-git clone https://github.com/<your-username>/remote-opencode.git
+git clone https://github.com/RoundTable02/remote-opencode.git
 cd remote-opencode
 npm install
 npm run build
@@ -103,9 +113,7 @@ Before using remote-opencode, you need to create a Discord Application and Bot.
 3. Enter a name (e.g., "Remote OpenCode")
 4. Copy the **Application ID** — you'll need this later
 
-<!-- SCREENSHOT: Discord Developer Portal - New Application button -->
-<!-- ![Create Application](./docs/images/01-create-application.png) -->
-*Screenshot placeholder: Discord Developer Portal showing "New Application" button*
+<img width="800" alt="image" src="https://github.com/user-attachments/assets/ca2e7ff3-91e7-4d66-93dc-c166189c0107" />
 
 ### Step 2: Create Bot & Get Token
 
@@ -114,9 +122,6 @@ Before using remote-opencode, you need to create a Discord Application and Bot.
 3. **Copy the token immediately** — it's only shown once!
 4. Keep this token secret — never share it publicly
 
-<!-- SCREENSHOT: Bot section showing Reset Token button -->
-<!-- ![Get Bot Token](./docs/images/02-bot-token.png) -->
-*Screenshot placeholder: Bot settings page with token section highlighted*
 
 ### Step 3: Enable Required Intents
 
@@ -127,36 +132,67 @@ Still in the **"Bot"** section, scroll down to **"Privileged Gateway Intents"**
 
 Click **"Save Changes"**
 
-<!-- SCREENSHOT: Privileged Gateway Intents toggles -->
-<!-- ![Enable Intents](./docs/images/03-intents.png) -->
-*Screenshot placeholder: Intents section with required toggles enabled*
+<img width="1500" alt="image" src="https://github.com/user-attachments/assets/d20406ff-26ad-4204-9771-b157c340846a" />
+
+### Step 4: Configure Bot Permissions
+
+The bot needs specific permissions to function properly. You can configure permissions in two ways:
+
+#### Option A: Using OAuth2 URL Generator (Recommended)
+
+1. Navigate to the **"OAuth2"** section in the sidebar
+2. Click on **"URL Generator"**
+3. In **"Scopes"**, select:
+   - ✅ `bot`
+   - ✅ `applications.commands`
+4. In **"Bot Permissions"**, select only these essential permissions:
+   
+   **General Permissions:**
+   - ✅ **View Channels** — Required to access channels
+   
+   **Text Permissions:**
+   - ✅ **Send Messages** — Send responses to channels
+   - ✅ **Create Public Threads** — Create threads for each `/opencode` session
+   - ✅ **Send Messages in Threads** — Reply within threads
+   - ✅ **Embed Links** — Send formatted embed messages
+   - ✅ **Read Message History** — Access context for conversations
+   - ✅ **Add Reactions** — Add buttons (uses emoji reactions internally)
+   - ✅ **Use Slash Commands** — Register and use slash commands
+
+5. Copy the generated URL at the bottom — this is your bot invite link!
+
 
-### Step 4: Get Your Server (Guild) ID
+#### Option B: Manual Permission Calculation
+
+If you're building the URL manually, use this permission value:
+
+```
+https://discord.com/api/oauth2/authorize?client_id=YOUR_CLIENT_ID&permissions=311385214016&integration_type=0&scope=bot+applications.commands
+```
+
+**Important:** The URL must include `applications.commands` scope for slash commands to work!
+
+### Step 5: Get Your Server (Guild) ID
 
 1. Open Discord and go to **User Settings → Advanced**
 2. Enable **"Developer Mode"**
 3. Right-click on your server name in the sidebar
 4. Click **"Copy Server ID"**
 
-<!-- SCREENSHOT: Discord showing Copy Server ID option -->
-<!-- ![Copy Server ID](./docs/images/04-guild-id.png) -->
-*Screenshot placeholder: Right-click menu showing "Copy Server ID" option*
+<img width="184" height="530" alt="스크린샷 2026-02-03 오전 2 34 31" src="https://github.com/user-attachments/assets/8ecc2a28-05e5-494f-834f-95d9d0e4e730" />
 
-### Step 5: Invite Bot to Your Server
+### Step 6: Invite Bot to Your Server
 
-The setup wizard generates an invite URL, or use this format:
+Use the URL generated in Step 4 (OAuth2 URL Generator), or construct it manually:
 
 ```
-https://discord.com/api/oauth2/authorize?client_id=YOUR_CLIENT_ID&permissions=2147534848&scope=bot
+https://discord.com/api/oauth2/authorize?client_id=YOUR_CLIENT_ID&permissions=218900185540&scope=bot%20applications.commands
 ```
 
 1. Replace `YOUR_CLIENT_ID` with your Application ID
 2. Open the URL in your browser
 3. Select your server and authorize
 
-<!-- SCREENSHOT: Bot authorization page -->
-<!-- ![Authorize Bot](./docs/images/05-authorize.png) -->
-*Screenshot placeholder: Discord OAuth2 authorization page*
 
 ---
 
@@ -242,6 +278,43 @@ Start isolated work on a new branch with its own worktree.
 
 This is perfect for working on multiple features simultaneously without branch switching.
 
+### `/code` — Toggle Passthrough Mode
+
+Enable passthrough mode in a thread to send messages directly to OpenCode without slash commands.
+
+```
+/code
+```
+
+**How it works:**
+1. Run `/code` in any thread to enable passthrough mode
+2. Type messages naturally — they're sent directly to OpenCode
+3. Run `/code` again to disable
+
+**Example:**
+```
+You: /code
+Bot: ✅ Passthrough mode enabled for this thread.
+     Your messages will be sent directly to OpenCode.
+
+You: Add a dark mode toggle to settings
+Bot: 📌 Prompt: Add a dark mode toggle to settings
+     [streaming response...]
+
+You: Now add a keyboard shortcut for it
+Bot: 📌 Prompt: Now add a keyboard shortcut for it
+     [streaming response...]
+
+You: /code
+Bot: ❌ Passthrough mode disabled.
+```
+
+**Features:**
+- 📱 **Mobile-friendly** — no more typing slash commands on phone
+- 🧵 **Thread-scoped** — only affects the specific thread, not the whole channel
+- ⏳ **Busy indicator** — shows ⏳ reaction if previous task is still running
+- 🔒 **Safe** — ignores bot messages (no infinite loops)
+
 ---
 
 ## Usage Workflow
@@ -278,6 +351,8 @@ Perfect for when you're away from your desk:
 4. Watch real-time progress
 5. Use the **Interrupt** button if needed
 
+**Pro tip:** Enable passthrough mode with `/code` in a thread for an even smoother mobile experience — just type messages directly without slash commands!
+
 ### Team Collaboration Workflow
 
 Share AI coding sessions with your team:
@@ -413,7 +488,7 @@ The bot maintains persistent sessions. If you encounter issues:
 ### Run from source
 
 ```bash
-git clone https://github.com/<your-username>/remote-opencode.git
+git clone https://github.com/RoundTable02/remote-opencode.git
 cd remote-opencode
 npm install
 
@@ -440,13 +515,15 @@ src/
 ├── bot.ts                 # Discord client initialization
 ├── commands/              # Slash command definitions
 │   ├── opencode.ts        # Main AI interaction command
+│   ├── code.ts            # Passthrough mode toggle
 │   ├── work.ts            # Worktree management
 │   ├── setpath.ts         # Project registration
 │   ├── projects.ts        # List projects
 │   └── use.ts             # Channel binding
 ├── handlers/              # Interaction handlers
 │   ├── interactionHandler.ts
-│   └── buttonHandler.ts
+│   ├── buttonHandler.ts
+│   └── messageHandler.ts  # Passthrough message handling
 ├── services/              # Core business logic
 │   ├── serveManager.ts    # OpenCode process management
 │   ├── sessionManager.ts  # Session state management

package/dist/src/bot.js

@@ -2,6 +2,7 @@ import { Client, GatewayIntentBits, Events } from 'discord.js';
 import pc from 'picocolors';
 import { getBotConfig } from './services/configStore.js';
 import { handleInteraction } from './handlers/interactionHandler.js';
+import { handleMessageCreate } from './handlers/messageHandler.js';
 import * as serveManager from './services/serveManager.js';
 export async function startBot() {
     const config = getBotConfig();
@@ -9,12 +10,17 @@ export async function startBot() {
         throw new Error('Bot configuration not found. Run setup first.');
     }
     const client = new Client({
-        intents: [GatewayIntentBits.Guilds, GatewayIntentBits.GuildMessages]
+        intents: [
+            GatewayIntentBits.Guilds,
+            GatewayIntentBits.GuildMessages,
+            GatewayIntentBits.MessageContent
+        ]
     });
     client.once(Events.ClientReady, (c) => {
         console.log(pc.green(`Ready! Logged in as ${pc.bold(c.user.tag)}`));
     });
     client.on(Events.InteractionCreate, handleInteraction);
+    client.on(Events.MessageCreate, handleMessageCreate);
     function gracefulShutdown(signal) {
         console.log(pc.yellow(`\n${signal} received. Shutting down gracefully...`));
         serveManager.stopAll();

package/dist/src/commands/code.js

@@ -0,0 +1,47 @@
+import { SlashCommandBuilder, MessageFlags } from 'discord.js';
+import * as dataStore from '../services/dataStore.js';
+export const code = {
+    data: new SlashCommandBuilder()
+        .setName('code')
+        .setDescription('Toggle passthrough mode - send messages directly to OpenCode'),
+    async execute(interaction) {
+        const channel = interaction.channel;
+        if (!channel?.isThread()) {
+            await interaction.reply({
+                content: '❌ This command only works inside threads.',
+                flags: MessageFlags.Ephemeral
+            });
+            return;
+        }
+        const threadId = channel.id;
+        const parentChannelId = channel.parentId;
+        if (!parentChannelId) {
+            await interaction.reply({
+                content: '❌ Cannot determine parent channel.',
+                flags: MessageFlags.Ephemeral
+            });
+            return;
+        }
+        const projectPath = dataStore.getChannelProjectPath(parentChannelId);
+        if (!projectPath) {
+            await interaction.reply({
+                content: '❌ No project set for this channel. Use `/use <alias>` in the parent channel first.',
+                flags: MessageFlags.Ephemeral
+            });
+            return;
+        }
+        const currentState = dataStore.isPassthroughEnabled(threadId);
+        const newState = !currentState;
+        dataStore.setPassthroughMode(threadId, newState, interaction.user.id);
+        if (newState) {
+            await interaction.reply({
+                content: '✅ **Passthrough mode enabled** for this thread.\nYour messages will be sent directly to OpenCode.',
+            });
+        }
+        else {
+            await interaction.reply({
+                content: '❌ **Passthrough mode disabled.**\nUse `/opencode prompt:"..."` to send commands.',
+            });
+        }
+    }
+};

package/dist/src/commands/index.js

@@ -4,9 +4,11 @@ import { projects } from './projects.js';
 import { use } from './use.js';
 import { opencode } from './opencode.js';
 import { work } from './work.js';
+import { code } from './code.js';
 export const commands = new Collection();
 commands.set(setpath.data.name, setpath);
 commands.set(projects.data.name, projects);
 commands.set(use.data.name, use);
 commands.set(opencode.data.name, opencode);
 commands.set(work.data.name, work);
+commands.set(code.data.name, code);

package/dist/src/handlers/messageHandler.js

@@ -0,0 +1,156 @@
+import { ActionRowBuilder, ButtonBuilder, ButtonStyle } from 'discord.js';
+import * as dataStore from '../services/dataStore.js';
+import * as sessionManager from '../services/sessionManager.js';
+import * as serveManager from '../services/serveManager.js';
+import { SSEClient } from '../services/sseClient.js';
+import { formatOutput } from '../utils/messageFormatter.js';
+export async function handleMessageCreate(message) {
+    if (message.author.bot)
+        return;
+    if (message.system)
+        return;
+    const channel = message.channel;
+    if (!channel.isThread())
+        return;
+    const threadId = channel.id;
+    if (!dataStore.isPassthroughEnabled(threadId))
+        return;
+    const parentChannelId = channel.parentId;
+    if (!parentChannelId)
+        return;
+    const projectPath = dataStore.getChannelProjectPath(parentChannelId);
+    if (!projectPath) {
+        await message.reply('❌ No project bound to parent channel. Disable passthrough and use `/use` first.');
+        return;
+    }
+    const worktreeMapping = dataStore.getWorktreeMapping(threadId);
+    const effectivePath = worktreeMapping?.worktreePath ?? projectPath;
+    const existingClient = sessionManager.getSseClient(threadId);
+    if (existingClient && existingClient.isConnected()) {
+        await message.react('⏳');
+        return;
+    }
+    const prompt = message.content.trim();
+    if (!prompt)
+        return;
+    const buttons = new ActionRowBuilder()
+        .addComponents(new ButtonBuilder()
+        .setCustomId(`interrupt_${threadId}`)
+        .setLabel('⏸️ Interrupt')
+        .setStyle(ButtonStyle.Secondary));
+    let streamMessage;
+    try {
+        streamMessage = await channel.send({
+            content: `📌 **Prompt**: ${prompt}\n\n🚀 Starting OpenCode server...`,
+            components: [buttons]
+        });
+    }
+    catch {
+        return;
+    }
+    let port;
+    let sessionId;
+    let updateInterval = null;
+    let accumulatedText = '';
+    let lastContent = '';
+    let tick = 0;
+    const spinner = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+    const updateStreamMessage = async (content, components) => {
+        try {
+            await streamMessage.edit({ content, components });
+        }
+        catch {
+        }
+    };
+    try {
+        port = await serveManager.spawnServe(effectivePath);
+        await updateStreamMessage(`📌 **Prompt**: ${prompt}\n\n⏳ Waiting for OpenCode server...`, [buttons]);
+        await serveManager.waitForReady(port);
+        const existingSession = sessionManager.getSessionForThread(threadId);
+        if (existingSession && existingSession.projectPath === effectivePath) {
+            const isValid = await sessionManager.validateSession(port, existingSession.sessionId);
+            if (isValid) {
+                sessionId = existingSession.sessionId;
+                sessionManager.updateSessionLastUsed(threadId);
+            }
+            else {
+                sessionId = await sessionManager.createSession(port);
+                sessionManager.setSessionForThread(threadId, sessionId, effectivePath, port);
+            }
+        }
+        else {
+            sessionId = await sessionManager.createSession(port);
+            sessionManager.setSessionForThread(threadId, sessionId, effectivePath, port);
+        }
+        const sseClient = new SSEClient();
+        sseClient.connect(`http://localhost:${port}`);
+        sessionManager.setSseClient(threadId, sseClient);
+        sseClient.onPartUpdated((part) => {
+            accumulatedText = part.text;
+        });
+        sseClient.onSessionIdle(() => {
+            if (updateInterval) {
+                clearInterval(updateInterval);
+                updateInterval = null;
+            }
+            (async () => {
+                try {
+                    const formatted = formatOutput(accumulatedText);
+                    const disabledButtons = new ActionRowBuilder()
+                        .addComponents(new ButtonBuilder()
+                        .setCustomId(`interrupt_${threadId}`)
+                        .setLabel('⏸️ Interrupt')
+                        .setStyle(ButtonStyle.Secondary)
+                        .setDisabled(true));
+                    await updateStreamMessage(`📌 **Prompt**: ${prompt}\n\n\`\`\`\n${formatted}\n\`\`\``, [disabledButtons]);
+                    await channel.send({ content: '✅ Done' });
+                    sseClient.disconnect();
+                    sessionManager.clearSseClient(threadId);
+                }
+                catch {
+                }
+            })();
+        });
+        sseClient.onError((error) => {
+            if (updateInterval) {
+                clearInterval(updateInterval);
+                updateInterval = null;
+            }
+            (async () => {
+                try {
+                    await updateStreamMessage(`📌 **Prompt**: ${prompt}\n\n❌ Connection error: ${error.message}`, []);
+                }
+                catch {
+                }
+            })();
+        });
+        updateInterval = setInterval(async () => {
+            tick++;
+            try {
+                const formatted = formatOutput(accumulatedText);
+                const spinnerChar = spinner[tick % spinner.length];
+                const newContent = formatted || 'Processing...';
+                if (newContent !== lastContent || tick % 2 === 0) {
+                    lastContent = newContent;
+                    await updateStreamMessage(`📌 **Prompt**: ${prompt}\n\n${spinnerChar} **Running...**\n\`\`\`\n${newContent}\n\`\`\``, [buttons]);
+                }
+            }
+            catch {
+            }
+        }, 1000);
+        await updateStreamMessage(`📌 **Prompt**: ${prompt}\n\n📝 Sending prompt...`, [buttons]);
+        await sessionManager.sendPrompt(port, sessionId, prompt);
+    }
+    catch (error) {
+        if (updateInterval) {
+            clearInterval(updateInterval);
+        }
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        await updateStreamMessage(`📌 **Prompt**: ${prompt}\n\n❌ OpenCode execution failed: ${errorMessage}`, []);
+        const client = sessionManager.getSseClient(threadId);
+        if (client) {
+            client.disconnect();
+            sessionManager.clearSseClient(threadId);
+        }
+    }
+}

package/dist/src/services/dataStore.js

@@ -150,3 +150,46 @@ export function getWorktreeMappingsByProject(projectPath) {
     const data = loadData();
     return data.worktreeMappings?.filter(m => m.projectPath === projectPath) ?? [];
 }
+export function setPassthroughMode(threadId, enabled, userId) {
+    const data = loadData();
+    if (!data.passthroughThreads) {
+        data.passthroughThreads = [];
+    }
+    const existing = data.passthroughThreads.findIndex(p => p.threadId === threadId);
+    if (existing >= 0) {
+        data.passthroughThreads[existing] = {
+            threadId,
+            enabled,
+            enabledBy: userId,
+            enabledAt: Date.now()
+        };
+    }
+    else {
+        data.passthroughThreads.push({
+            threadId,
+            enabled,
+            enabledBy: userId,
+            enabledAt: Date.now()
+        });
+    }
+    saveData(data);
+}
+export function getPassthroughMode(threadId) {
+    const data = loadData();
+    return data.passthroughThreads?.find(p => p.threadId === threadId);
+}
+export function isPassthroughEnabled(threadId) {
+    const passthrough = getPassthroughMode(threadId);
+    return passthrough?.enabled ?? false;
+}
+export function removePassthroughMode(threadId) {
+    const data = loadData();
+    if (!data.passthroughThreads)
+        return false;
+    const idx = data.passthroughThreads.findIndex(p => p.threadId === threadId);
+    if (idx < 0)
+        return false;
+    data.passthroughThreads.splice(idx, 1);
+    saveData(data);
+    return true;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "remote-opencode",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Discord bot for remote OpenCode CLI access",
   "main": "dist/src/index.js",
   "bin": {