remote-opencode 1.0.2 → 1.0.4

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
@@ -75,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
@@ -109,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
 
@@ -120,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
 
@@ -133,9 +132,7 @@ 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
 
@@ -164,35 +161,15 @@ The bot needs specific permissions to function properly. You can configure permi
 
 5. Copy the generated URL at the bottom — this is your bot invite link!
 
-<!-- SCREENSHOT: OAuth2 URL Generator showing selected permissions -->
-<!-- ![OAuth2 Permissions](./docs/images/03b-oauth2-permissions.png) -->
-*Screenshot placeholder: OAuth2 URL Generator with bot permissions selected*
 
 #### 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=343932274624&scope=bot%20applications.commands
+https://discord.com/api/oauth2/authorize?client_id=YOUR_CLIENT_ID&permissions=311385214016&integration_type=0&scope=bot+applications.commands
 ```
 
-**Permission Breakdown (343932274624):**
-
-| Permission | Value | Purpose |
-|------------|-------|---------|
-| View Channels | 1024 | Access channels and read messages |
-| Send Messages | 2048 | Send messages to channels |
-| Create Public Threads | 68719476736 | Create threads for each `/opencode` command |
-| Send Messages in Threads | 274877906944 | Reply within created threads |
-| Embed Links | 16384 | Send rich embed messages with formatting |
-| Read Message History | 65536 | Access previous messages for context |
-| Add Reactions | 64 | Add button components (uses emoji reactions) |
-| Use Slash Commands | 2147483648 | Register and respond to slash commands |
-
-**Optional Permissions (not required):**
-- **Attach Files** (32768) — Only if you want to upload files
-- **Mention @everyone** (131072) — Only if bot needs to ping everyone
-
 **Important:** The URL must include `applications.commands` scope for slash commands to work!
 
 ### Step 5: Get Your Server (Guild) ID
@@ -202,25 +179,20 @@ https://discord.com/api/oauth2/authorize?client_id=YOUR_CLIENT_ID&permissions=34
 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 6: Invite Bot to Your Server
 
 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=343932274624&scope=bot%20applications.commands
+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*
 
 ---
 
@@ -306,6 +278,77 @@ 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)
+
+### `/autowork` — Toggle Automatic Worktree Creation
+
+Enable automatic worktree creation for a project. When enabled, new `/opencode` sessions will automatically create isolated git worktrees.
+
+```
+/autowork
+```
+
+**How it works:**
+1. Run `/autowork` in a channel bound to a project
+2. The setting toggles on/off for that project
+3. When enabled, new sessions automatically create worktrees with branch names like `auto/abc12345-1738600000000`
+
+**Example:**
+```
+You: /autowork
+Bot: ✅ Auto-worktree enabled for project myapp.
+     New sessions will automatically create isolated worktrees.
+
+You: /opencode prompt:Add user authentication
+Bot: [Creates thread + auto-worktree]
+     🌳 Auto-Worktree: auto/abc12345-1738600000000
+     [Delete] [Create PR]
+     📌 Prompt: Add user authentication
+     [streaming response...]
+```
+
+**Features:**
+- 🌳 **Automatic isolation** — each session gets its own branch and worktree
+- 📱 **Mobile-friendly** — no need to type `/work` with branch names
+- 🗑️ **Delete button** — removes worktree when done
+- 🚀 **Create PR button** — easily create pull requests from worktree
+- ⚡ **Per-project setting** — enable/disable independently for each project
+
 ---
 
 ## Usage Workflow
@@ -342,6 +385,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:
@@ -396,17 +441,21 @@ All configuration is stored in `~/.remote-opencode/`:
 
 ```json
 {
-  "projects": {
-    "myapp": "/Users/you/projects/my-app"
-  },
-  "bindings": {
-    "channel-id": "myapp"
-  },
-  "threadSessions": { ... },
-  "worktreeMappings": { ... }
+  "projects": [
+    { "alias": "myapp", "path": "/Users/you/projects/my-app", "autoWorktree": true }
+  ],
+  "bindings": [
+    { "channelId": "channel-id", "projectAlias": "myapp" }
+  ],
+  "threadSessions": [ ... ],
+  "worktreeMappings": [ ... ]
 }
 ```
 
+| Field | Description |
+|-------|-------------|
+| `projects[].autoWorktree` | Optional. When `true`, new sessions auto-create worktrees |
+
 ---
 
 ## Troubleshooting
@@ -477,7 +526,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
 
@@ -504,13 +553,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/cli.js

@@ -1,15 +1,18 @@
 #!/usr/bin/env node
 import { Command } from 'commander';
 import pc from 'picocolors';
+import { createRequire } from 'module';
 import { runSetupWizard } from './setup/wizard.js';
 import { deployCommands } from './setup/deploy.js';
 import { startBot } from './bot.js';
 import { hasBotConfig, getConfigDir } from './services/configStore.js';
+const require = createRequire(import.meta.url);
+const pkg = require('../../package.json');
 const program = new Command();
 program
     .name('remote-opencode')
     .description('Discord bot for remote OpenCode CLI access')
-    .version('1.0.0');
+    .version(pkg.version);
 program
     .command('start')
     .description('Start the Discord bot')
@@ -19,6 +22,12 @@ program
         console.log(`Run ${pc.cyan('remote-opencode setup')} first to configure your Discord bot.\n`);
         process.exit(1);
     }
+    try {
+        await deployCommands();
+    }
+    catch {
+        console.log(pc.dim('Command deployment skipped (will retry on next start)'));
+    }
     await startBot();
 });
 program

package/dist/src/commands/autowork.js

@@ -0,0 +1,41 @@
+import { SlashCommandBuilder, MessageFlags } from 'discord.js';
+import * as dataStore from '../services/dataStore.js';
+function getParentChannelId(interaction) {
+    const channel = interaction.channel;
+    if (channel?.isThread()) {
+        return channel.parentId ?? interaction.channelId;
+    }
+    return interaction.channelId;
+}
+export const autowork = {
+    data: new SlashCommandBuilder()
+        .setName('autowork')
+        .setDescription('Toggle automatic worktree creation for this channel\'s project'),
+    async execute(interaction) {
+        const channelId = getParentChannelId(interaction);
+        const projectAlias = dataStore.getChannelBinding(channelId);
+        if (!projectAlias) {
+            await interaction.reply({
+                content: '❌ No project set for this channel. Use `/use <alias>` to bind a project first.',
+                flags: MessageFlags.Ephemeral
+            });
+            return;
+        }
+        const currentState = dataStore.getProjectAutoWorktree(projectAlias);
+        const newState = !currentState;
+        const success = dataStore.setProjectAutoWorktree(projectAlias, newState);
+        if (!success) {
+            await interaction.reply({
+                content: `❌ Project "${projectAlias}" not found.`,
+                flags: MessageFlags.Ephemeral
+            });
+            return;
+        }
+        const emoji = newState ? '✅' : '❌';
+        const status = newState ? 'enabled' : 'disabled';
+        await interaction.reply({
+            content: `${emoji} Auto-worktree **${status}** for project **${projectAlias}**.\n\nNew sessions will ${newState ? 'automatically create' : 'NOT create'} isolated worktrees.`,
+            flags: MessageFlags.Ephemeral
+        });
+    }
+};

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,13 @@ 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';
+import { autowork } from './autowork.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);
+commands.set(autowork.data.name, autowork);

package/dist/src/commands/opencode.js

@@ -1,7 +1,8 @@
-import { SlashCommandBuilder, ActionRowBuilder, ButtonBuilder, ButtonStyle, MessageFlags } from 'discord.js';
+import { SlashCommandBuilder, ActionRowBuilder, ButtonBuilder, ButtonStyle, MessageFlags, EmbedBuilder } 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 * as worktreeManager from '../services/worktreeManager.js';
 import { SSEClient } from '../services/sseClient.js';
 import { getOrCreateThread } from '../utils/threadHelper.js';
 import { formatOutput } from '../utils/messageFormatter.js';
@@ -48,7 +49,45 @@ export const opencode = {
             return;
         }
         const threadId = thread.id;
-        const worktreeMapping = dataStore.getWorktreeMapping(threadId);
+        // Auto-create worktree if enabled and this is a new thread (not isInThread)
+        let worktreeMapping = dataStore.getWorktreeMapping(threadId);
+        if (!worktreeMapping && !isInThread) {
+            const projectAlias = dataStore.getChannelBinding(channelId);
+            if (projectAlias && dataStore.getProjectAutoWorktree(projectAlias)) {
+                try {
+                    const branchName = worktreeManager.sanitizeBranchName(`auto/${threadId.slice(0, 8)}-${Date.now()}`);
+                    const worktreePath = await worktreeManager.createWorktree(projectPath, branchName);
+                    const newMapping = {
+                        threadId,
+                        branchName,
+                        worktreePath,
+                        projectPath,
+                        description: prompt.slice(0, 50) + (prompt.length > 50 ? '...' : ''),
+                        createdAt: Date.now()
+                    };
+                    dataStore.setWorktreeMapping(newMapping);
+                    worktreeMapping = newMapping;
+                    const embed = new EmbedBuilder()
+                        .setTitle(`🌳 Auto-Worktree: ${branchName}`)
+                        .setDescription('Automatically created for this session')
+                        .addFields({ name: 'Branch', value: branchName, inline: true }, { name: 'Path', value: worktreePath, inline: true })
+                        .setColor(0x2ecc71);
+                    const worktreeButtons = new ActionRowBuilder()
+                        .addComponents(new ButtonBuilder()
+                        .setCustomId(`delete_${threadId}`)
+                        .setLabel('Delete')
+                        .setStyle(ButtonStyle.Danger), new ButtonBuilder()
+                        .setCustomId(`pr_${threadId}`)
+                        .setLabel('Create PR')
+                        .setStyle(ButtonStyle.Primary));
+                    await thread.send({ embeds: [embed], components: [worktreeButtons] });
+                }
+                catch (error) {
+                    console.error('Auto-worktree creation failed:', error);
+                    // Continue with main project path (graceful degradation)
+                }
+            }
+        }
         const effectivePath = worktreeMapping?.worktreePath ?? projectPath;
         const existingClient = sessionManager.getSseClient(threadId);
         if (existingClient && existingClient.isConnected()) {

package/dist/src/handlers/messageHandler.js

@@ -0,0 +1,196 @@
+import { ActionRowBuilder, ButtonBuilder, ButtonStyle, EmbedBuilder } 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 * as worktreeManager from '../services/worktreeManager.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;
+    }
+    let worktreeMapping = dataStore.getWorktreeMapping(threadId);
+    // Auto-create worktree if enabled and no mapping exists for this thread
+    if (!worktreeMapping) {
+        const projectAlias = dataStore.getChannelBinding(parentChannelId);
+        if (projectAlias && dataStore.getProjectAutoWorktree(projectAlias)) {
+            try {
+                const branchName = worktreeManager.sanitizeBranchName(`auto/${threadId.slice(0, 8)}-${Date.now()}`);
+                const worktreePath = await worktreeManager.createWorktree(projectPath, branchName);
+                const prompt = message.content.trim();
+                const newMapping = {
+                    threadId,
+                    branchName,
+                    worktreePath,
+                    projectPath,
+                    description: prompt.slice(0, 50) + (prompt.length > 50 ? '...' : ''),
+                    createdAt: Date.now()
+                };
+                dataStore.setWorktreeMapping(newMapping);
+                worktreeMapping = newMapping;
+                const embed = new EmbedBuilder()
+                    .setTitle(`🌳 Auto-Worktree: ${branchName}`)
+                    .setDescription('Automatically created for this session')
+                    .addFields({ name: 'Branch', value: branchName, inline: true }, { name: 'Path', value: worktreePath, inline: true })
+                    .setColor(0x2ecc71);
+                const worktreeButtons = new ActionRowBuilder()
+                    .addComponents(new ButtonBuilder()
+                    .setCustomId(`delete_${threadId}`)
+                    .setLabel('Delete')
+                    .setStyle(ButtonStyle.Danger), new ButtonBuilder()
+                    .setCustomId(`pr_${threadId}`)
+                    .setLabel('Create PR')
+                    .setStyle(ButtonStyle.Primary));
+                await channel.send({ embeds: [embed], components: [worktreeButtons] });
+            }
+            catch (error) {
+                console.error('Auto-worktree creation failed:', error);
+                // Continue with main project path (graceful degradation)
+            }
+        }
+    }
+    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,59 @@ 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;
+}
+export function setProjectAutoWorktree(alias, enabled) {
+    const data = loadData();
+    const project = data.projects.find(p => p.alias === alias);
+    if (!project)
+        return false;
+    project.autoWorktree = enabled;
+    saveData(data);
+    return true;
+}
+export function getProjectAutoWorktree(alias) {
+    const project = getProject(alias);
+    return project?.autoWorktree ?? false;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "remote-opencode",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "Discord bot for remote OpenCode CLI access",
   "main": "dist/src/index.js",
   "bin": {
@@ -19,7 +19,10 @@
     "dev": "node --loader ts-node/esm src/cli.ts",
     "deploy-commands": "npm run build && node dist/src/cli.js deploy",
     "test": "vitest",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "npm run build",
+    "release": "npm version patch && npm run build && npm publish",
+    "release:minor": "npm version minor && npm run build && npm publish",
+    "release:major": "npm version major && npm run build && npm publish"
   },
   "keywords": [
     "discord",