remote-opencode 1.0.8 → 1.0.10

package/README.md

@@ -12,9 +12,11 @@
 - 💻 **Access from any device** — Use your powerful dev machine from a laptop or tablet
 - 🌍 **Work remotely** — Control your home/office workstation from anywhere
 - 👥 **Collaborate** — Share AI coding sessions with team members in Discord
+- 🤖 **Automated Workflows** — Queue up multiple tasks and let the bot process them sequentially
 
 ## How It Works
 
+
 ```
 ┌─────────────────┐    Discord API    ┌─────────────────┐
 │  Your Phone /   │ ◄──────────────► │  Discord Bot    │
@@ -48,6 +50,7 @@ The bot runs on your development machine alongside OpenCode. When you send a com
 - [Configuration](#configuration)
 - [Troubleshooting](#troubleshooting)
 - [Development](#development)
+- [Changelog](#changelog)
 - [License](#license)
 
 ---
@@ -257,20 +260,6 @@ Enable automatic worktree creation for a project. When enabled, new `/opencode`
 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
@@ -278,8 +267,30 @@ Bot: [Creates thread + auto-worktree]
 - 🚀 **Create PR button** — easily create pull requests from worktree
 - ⚡ **Per-project setting** — enable/disable independently for each project
 
+### `/queue` — Manage Message Queue
+
+Control the automated job queue for the current thread.
+
+```
+/queue list
+/queue clear
+/queue pause
+/queue resume
+/queue settings continue_on_failure:True fresh_context:True
+```
+
+**How it works:**
+1. Send multiple messages to a thread (or use `/opencode` multiple times)
+2. If the bot is busy, it reacts with `📥` and adds the task to the queue
+3. Once the current job is done, the bot automatically picks up the next one
+
+**Settings:**
+- `continue_on_failure`: If `True`, the bot moves to the next task even if the current one fails.
+- `fresh_context`: If `True` (default), the AI forgets previous chat history for each new queued task to improve performance, while maintaining the same code state.
+
 ---
 
+
 ## Usage Workflow
 
 ### Basic Workflow
@@ -325,28 +336,27 @@ Share AI coding sessions with your team:
 3. Team members can watch sessions in real-time
 4. Discuss in threads while AI works
 
-### Worktree Workflow (Parallel Features)
-
-Work on multiple features without conflicts:
+### Automated Iteration Workflow
 
-1. **Start a new feature:**
-   ```
-   /work branch:feature/auth description:Implement OAuth2 login
-   ```
+Perfect for "setting and forgetting" several tasks:
 
-2. **Work in the created thread:**
+1. **Send multiple instructions:**
    ```
-   /opencode prompt:Add Google OAuth provider
+   You: Refactor the API
+   Bot: [Starts working]
+   You: Add documentation to the new methods
+   Bot: 📥 [Queued]
+   You: Run tests and fix any issues
+   Bot: 📥 [Queued]
    ```
 
-3. **When done, create a PR:**
-   Click the **Create PR** button
+2. **The bot will finish the API refactor, then automatically start the documentation task, then run the tests.**
 
-4. **Clean up:**
-   Click **Delete** to remove the worktree
+3. **Monitor progress:** Use `/queue list` to see pending tasks.
 
 ---
 
+
 ## Configuration
 
 All configuration is stored in `~/.remote-opencode/`:
@@ -494,7 +504,10 @@ src/
 ├── services/              # Core business logic
 │   ├── serveManager.ts    # OpenCode process management
 │   ├── sessionManager.ts  # Session state management
+│   ├── queueManager.ts    # Automated job queuing
+│   ├── executionService.ts # Core prompt execution logic
 │   ├── sseClient.ts       # Real-time event streaming
+
 │   ├── dataStore.ts       # Persistent storage
 │   ├── configStore.ts     # Bot configuration
 │   └── worktreeManager.ts # Git worktree operations
@@ -508,6 +521,38 @@ src/
 
 ---
 
+## Changelog
+
+See [CHANGELOG.md](CHANGELOG.md) for a full history of changes.
+
+### [1.1.0] - 2026-02-05
+
+#### Added
+- **Automated Message Queuing**: Added a new system to queue multiple prompts in a thread. If the bot is busy, new messages are automatically queued and processed sequentially.
+- **Queue Management**: New `/queue` slash command suite to list, clear, pause, resume, and configure queue settings.
+
+### [1.0.10] - 2026-02-04
+
+#### Added
+- New `/setports` slash command to configure the port range for OpenCode server instances.
+
+#### Fixed
+- Fixed Windows-specific spawning issue (targeting `opencode.cmd`).
+- Resolved `spawn EINVAL` errors on Windows.
+- Improved server reliability and suppressed `DEP0190` security warnings.
+
+### [1.0.9] - 2026-02-04
+
+#### Added
+- New `/model` slash command to set AI models per channel.
+- Support for `--model` flag in OpenCode server instances.
+
+#### Fixed
+- Fixed connection timeout issues.
+- Standardized internal communication to use `127.0.0.1`.
+
+---
+
 ## License
 
 MIT

package/dist/src/__tests__/queueManager.test.js

@@ -0,0 +1,72 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { processNextInQueue, isBusy } from '../services/queueManager.js';
+import * as dataStore from '../services/dataStore.js';
+import * as executionService from '../services/executionService.js';
+import * as sessionManager from '../services/sessionManager.js';
+vi.mock('../services/dataStore.js');
+vi.mock('../services/executionService.js');
+vi.mock('../services/sessionManager.js');
+describe('queueManager', () => {
+    const threadId = 'thread-1';
+    const parentId = 'channel-1';
+    const mockChannel = {
+        send: vi.fn().mockResolvedValue({})
+    };
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('isBusy', () => {
+        it('should return true if sseClient is connected', () => {
+            vi.mocked(sessionManager.getSseClient).mockReturnValue({
+                isConnected: () => true
+            });
+            expect(isBusy(threadId)).toBe(true);
+        });
+        it('should return false if sseClient is not connected', () => {
+            vi.mocked(sessionManager.getSseClient).mockReturnValue({
+                isConnected: () => false
+            });
+            expect(isBusy(threadId)).toBe(false);
+        });
+        it('should return false if sseClient is missing', () => {
+            vi.mocked(sessionManager.getSseClient).mockReturnValue(undefined);
+            expect(isBusy(threadId)).toBe(false);
+        });
+    });
+    describe('processNextInQueue', () => {
+        it('should do nothing if queue is paused', async () => {
+            vi.mocked(dataStore.getQueueSettings).mockReturnValue({
+                paused: true,
+                continueOnFailure: false,
+                freshContext: true
+            });
+            await processNextInQueue(mockChannel, threadId, parentId);
+            expect(dataStore.popFromQueue).not.toHaveBeenCalled();
+        });
+        it('should pop and run next prompt if not paused', async () => {
+            vi.mocked(dataStore.getQueueSettings).mockReturnValue({
+                paused: false,
+                continueOnFailure: false,
+                freshContext: true
+            });
+            vi.mocked(dataStore.popFromQueue).mockReturnValue({
+                prompt: 'test prompt',
+                userId: 'user-1',
+                timestamp: Date.now()
+            });
+            await processNextInQueue(mockChannel, threadId, parentId);
+            expect(dataStore.popFromQueue).toHaveBeenCalledWith(threadId);
+            expect(executionService.runPrompt).toHaveBeenCalledWith(mockChannel, threadId, 'test prompt', parentId);
+        });
+        it('should do nothing if queue is empty', async () => {
+            vi.mocked(dataStore.getQueueSettings).mockReturnValue({
+                paused: false,
+                continueOnFailure: false,
+                freshContext: true
+            });
+            vi.mocked(dataStore.popFromQueue).mockReturnValue(undefined);
+            await processNextInQueue(mockChannel, threadId, parentId);
+            expect(executionService.runPrompt).not.toHaveBeenCalled();
+        });
+    });
+});

package/dist/src/__tests__/serveManager.test.js

@@ -17,7 +17,11 @@ vi.mock('node:net', () => ({
         }
     },
 }));
+vi.mock('../services/configStore.js', () => ({
+    getPortConfig: vi.fn(),
+}));
 import * as serveManager from '../services/serveManager.js';
+import { getPortConfig } from '../services/configStore.js';
 import { spawn } from 'node:child_process';
 const createMockProcess = () => {
     const proc = new EventEmitter();
@@ -32,7 +36,7 @@ const createMockProcess = () => {
 };
 describe('serveManager', () => {
     beforeEach(() => {
-        vi.clearAllMocks();
+        vi.resetAllMocks();
     });
     afterEach(() => {
         serveManager.stopAll();
@@ -47,6 +51,7 @@ describe('serveManager', () => {
             expect(port).toBeLessThanOrEqual(14200);
             expect(spawn).toHaveBeenCalledWith('opencode', ['serve', '--port', port.toString()], expect.objectContaining({
                 cwd: projectPath,
+                shell: true,
             }));
         });
         it('should return existing port if serve already running for project', async () => {
@@ -65,6 +70,13 @@ describe('serveManager', () => {
             expect(port1).not.toBe(port2);
             expect(spawn).toHaveBeenCalledTimes(2);
         });
+        it('should respect custom port range from config', async () => {
+            vi.mocked(spawn).mockImplementation(() => createMockProcess());
+            vi.mocked(getPortConfig).mockReturnValue({ min: 20000, max: 20010 });
+            const port = await serveManager.spawnServe('/test/custom-port');
+            expect(port).toBe(20000);
+            expect(spawn).toHaveBeenCalledWith('opencode', ['serve', '--port', '20000'], expect.anything());
+        });
         it('should clean up when process exits', async () => {
             const mockProc = createMockProcess();
             vi.mocked(spawn).mockReturnValue(mockProc);
@@ -72,7 +84,51 @@ describe('serveManager', () => {
             await serveManager.spawnServe(projectPath);
             expect(serveManager.getPort(projectPath)).toBeDefined();
             mockProc.emit('exit', 0, null);
-            expect(serveManager.getPort(projectPath)).toBeUndefined();
+            // Wait for async exit handler
+            await new Promise(resolve => setTimeout(resolve, 10));
+            // Instance should still exist but be marked as exited
+            const state = serveManager.getInstanceState(projectPath);
+            expect(state?.exited).toBe(true);
+            expect(state?.exitCode).toBe(0);
+        });
+        it('should track error message when process exits with non-zero code', async () => {
+            const mockProc = createMockProcess();
+            vi.mocked(spawn).mockReturnValue(mockProc);
+            const projectPath = '/test/project';
+            await serveManager.spawnServe(projectPath);
+            // Simulate stderr output before exit
+            mockProc.stderr?.emit('data', Buffer.from('Error: opencode command not found'));
+            mockProc.emit('exit', 1, null);
+            await new Promise(resolve => setTimeout(resolve, 10));
+            const state = serveManager.getInstanceState(projectPath);
+            expect(state?.exited).toBe(true);
+            expect(state?.exitCode).toBe(1);
+            expect(state?.exitError).toContain('opencode command not found');
+        });
+        it('should track error message when process fails to spawn', async () => {
+            const mockProc = createMockProcess();
+            vi.mocked(spawn).mockReturnValue(mockProc);
+            const projectPath = '/test/project';
+            await serveManager.spawnServe(projectPath);
+            mockProc.emit('error', new Error('spawn opencode ENOENT'));
+            await new Promise(resolve => setTimeout(resolve, 10));
+            const state = serveManager.getInstanceState(projectPath);
+            expect(state?.exited).toBe(true);
+            expect(state?.exitError).toContain('spawn opencode ENOENT');
+        });
+        it('should allow respawning after process exits', async () => {
+            vi.mocked(spawn).mockImplementation(() => createMockProcess());
+            const projectPath = '/test/project';
+            const port1 = await serveManager.spawnServe(projectPath);
+            // Get the mock process and mark it as exited
+            const mockProc1 = vi.mocked(spawn).mock.results[0].value;
+            mockProc1.emit('exit', 1, null);
+            await new Promise(resolve => setTimeout(resolve, 10));
+            // Should spawn a new process
+            const port2 = await serveManager.spawnServe(projectPath);
+            expect(spawn).toHaveBeenCalledTimes(2);
+            // Port might be the same or different depending on cleanup timing
+            expect(port2).toBeGreaterThanOrEqual(14097);
         });
     });
     describe('getPort', () => {
@@ -138,7 +194,7 @@ describe('serveManager', () => {
             const promise = serveManager.waitForReady(14097);
             await vi.runAllTimersAsync();
             await expect(promise).resolves.toBeUndefined();
-            expect(fetch).toHaveBeenCalledWith('http://localhost:14097/session');
+            expect(fetch).toHaveBeenCalledWith('http://127.0.0.1:14097/session');
         });
         it('should retry if fetch fails or returns not ok', async () => {
             vi.mocked(fetch)
@@ -147,14 +203,38 @@ describe('serveManager', () => {
                 .mockResolvedValueOnce({ ok: true });
             const promise = serveManager.waitForReady(14097);
             await vi.advanceTimersByTimeAsync(0);
-            await vi.advanceTimersByTimeAsync(500);
-            await vi.advanceTimersByTimeAsync(500);
+            await vi.advanceTimersByTimeAsync(1000);
+            await vi.advanceTimersByTimeAsync(1000);
             await expect(promise).resolves.toBeUndefined();
             expect(fetch).toHaveBeenCalledTimes(3);
         });
         it('should throw error on timeout', async () => {
             vi.mocked(fetch).mockRejectedValue(new Error('Connection refused'));
             const promise = serveManager.waitForReady(14097, 1000);
+            const wrappedPromise = expect(promise).rejects.toThrow('Service at port 14097 failed to become ready within 1000ms. Check if \'opencode serve\' is working correctly.');
+            await vi.advanceTimersByTimeAsync(1500);
+            await wrappedPromise;
+        });
+        it('should fail fast when process exits early with error', async () => {
+            vi.useRealTimers();
+            vi.mocked(fetch).mockRejectedValue(new Error('Connection refused'));
+            const mockProc = createMockProcess();
+            vi.mocked(spawn).mockReturnValue(mockProc);
+            const projectPath = '/test/fast-fail';
+            const port = await serveManager.spawnServe(projectPath);
+            // Simulate stderr output and immediate exit
+            mockProc.stderr?.emit('data', Buffer.from('Error: Failed to bind to port'));
+            mockProc.emit('exit', 1, null);
+            // Wait for exit handler to process
+            await new Promise(resolve => setTimeout(resolve, 10));
+            // Now waitForReady should fail fast with the error message
+            await expect(serveManager.waitForReady(port, 30000, projectPath)).rejects.toThrow('opencode serve failed to start: Error: Failed to bind to port');
+            vi.useFakeTimers();
+        });
+        it('should still timeout if no projectPath provided and process exits', async () => {
+            vi.mocked(fetch).mockRejectedValue(new Error('Connection refused'));
+            // Without projectPath, can't detect early exit
+            const promise = serveManager.waitForReady(14097, 1000);
             const wrappedPromise = expect(promise).rejects.toThrow('Service at port 14097 failed to become ready within 1000ms');
             await vi.advanceTimersByTimeAsync(1500);
             await wrappedPromise;

package/dist/src/__tests__/sessionManager.test.js

@@ -18,7 +18,7 @@ describe('SessionManager', () => {
                 json: async () => ({ id: mockSessionId, slug: 'test-session' }),
             });
             const sessionId = await createSession(3000);
-            expect(mockFetch).toHaveBeenCalledWith('http://localhost:3000/session', {
+            expect(mockFetch).toHaveBeenCalledWith('http://127.0.0.1:3000/session', {
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json' },
                 body: '{}',
@@ -48,7 +48,7 @@ describe('SessionManager', () => {
                 status: 204,
             });
             await sendPrompt(3000, 'ses_abc123', 'Hello OpenCode');
-            expect(mockFetch).toHaveBeenCalledWith('http://localhost:3000/session/ses_abc123/prompt_async', {
+            expect(mockFetch).toHaveBeenCalledWith('http://127.0.0.1:3000/session/ses_abc123/prompt_async', {
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json' },
                 body: JSON.stringify({
@@ -56,6 +56,21 @@ describe('SessionManager', () => {
                 }),
             });
         });
+        it('should include model in payload when provided', async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                status: 204,
+            });
+            await sendPrompt(3000, 'ses_abc123', 'Hello OpenCode', 'llm-proxy/ant_gemini-3-flash');
+            expect(mockFetch).toHaveBeenCalledWith('http://127.0.0.1:3000/session/ses_abc123/prompt_async', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    parts: [{ type: 'text', text: 'Hello OpenCode' }],
+                    model: { providerID: 'llm-proxy', modelID: 'ant_gemini-3-flash' },
+                }),
+            });
+        });
         it('should throw error if HTTP request fails', async () => {
             mockFetch.mockResolvedValueOnce({
                 ok: false,

package/dist/src/__tests__/sseClient.test.js

@@ -32,22 +32,22 @@ describe('SSEClient', () => {
     });
     describe('connect', () => {
         it('should connect to SSE endpoint', () => {
-            client.connect('http://localhost:3000');
-            expect(MockEventSource).toHaveBeenCalledWith('http://localhost:3000/event');
+            client.connect('http://127.0.0.1:3000');
+            expect(MockEventSource).toHaveBeenCalledWith('http://127.0.0.1:3000/event');
         });
         it('should set up message event listener', () => {
-            client.connect('http://localhost:3000');
+            client.connect('http://127.0.0.1:3000');
             expect(mockEventSourceInstance.addEventListener).toHaveBeenCalledWith('message', expect.any(Function));
         });
         it('should set up error event listener', () => {
-            client.connect('http://localhost:3000');
+            client.connect('http://127.0.0.1:3000');
             expect(mockEventSourceInstance.addEventListener).toHaveBeenCalledWith('error', expect.any(Function));
         });
     });
     describe('onPartUpdated', () => {
         it('should trigger callback for text part updates', () => {
             const callback = vi.fn();
-            client.connect('http://localhost:3000');
+            client.connect('http://127.0.0.1:3000');
             client.onPartUpdated(callback);
             const messageHandler = mockEventSourceInstance.addEventListener.mock.calls.find((call) => call[0] === 'message')?.[1];
             const event = {
@@ -74,7 +74,7 @@ describe('SSEClient', () => {
         });
         it('should not trigger callback for non-text parts', () => {
             const callback = vi.fn();
-            client.connect('http://localhost:3000');
+            client.connect('http://127.0.0.1:3000');
             client.onPartUpdated(callback);
             const messageHandler = mockEventSourceInstance.addEventListener.mock.calls.find((call) => call[0] === 'message')?.[1];
             const event = {
@@ -95,7 +95,7 @@ describe('SSEClient', () => {
         });
         it('should not trigger callback for non-part-updated events', () => {
             const callback = vi.fn();
-            client.connect('http://localhost:3000');
+            client.connect('http://127.0.0.1:3000');
             client.onPartUpdated(callback);
             const messageHandler = mockEventSourceInstance.addEventListener.mock.calls.find((call) => call[0] === 'message')?.[1];
             const event = {
@@ -111,7 +111,7 @@ describe('SSEClient', () => {
     describe('onSessionIdle', () => {
         it('should trigger callback for session.idle events', () => {
             const callback = vi.fn();
-            client.connect('http://localhost:3000');
+            client.connect('http://127.0.0.1:3000');
             client.onSessionIdle(callback);
             const messageHandler = mockEventSourceInstance.addEventListener.mock.calls.find((call) => call[0] === 'message')?.[1];
             const event = {
@@ -127,7 +127,7 @@ describe('SSEClient', () => {
         });
         it('should not trigger callback for non-idle events', () => {
             const callback = vi.fn();
-            client.connect('http://localhost:3000');
+            client.connect('http://127.0.0.1:3000');
             client.onSessionIdle(callback);
             const messageHandler = mockEventSourceInstance.addEventListener.mock.calls.find((call) => call[0] === 'message')?.[1];
             const event = {
@@ -143,7 +143,7 @@ describe('SSEClient', () => {
     describe('onError', () => {
         it('should trigger callback on error', () => {
             const callback = vi.fn();
-            client.connect('http://localhost:3000');
+            client.connect('http://127.0.0.1:3000');
             client.onError(callback);
             const errorHandler = mockEventSourceInstance.addEventListener.mock.calls.find((call) => call[0] === 'error')?.[1];
             const error = new Error('Connection failed');
@@ -153,7 +153,7 @@ describe('SSEClient', () => {
     });
     describe('disconnect', () => {
         it('should close the connection', () => {
-            client.connect('http://localhost:3000');
+            client.connect('http://127.0.0.1:3000');
             client.disconnect();
             expect(mockEventSourceInstance.close).toHaveBeenCalled();
         });
@@ -163,12 +163,12 @@ describe('SSEClient', () => {
     });
     describe('isConnected', () => {
         it('should return true when connected', () => {
-            client.connect('http://localhost:3000');
+            client.connect('http://127.0.0.1:3000');
             mockEventSourceInstance.readyState = 1;
             expect(client.isConnected()).toBe(true);
         });
         it('should return false when disconnected', () => {
-            client.connect('http://localhost:3000');
+            client.connect('http://127.0.0.1:3000');
             mockEventSourceInstance.readyState = 2;
             expect(client.isConnected()).toBe(false);
         });

package/dist/src/cli.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+process.removeAllListeners('warning');
 import { Command } from 'commander';
 import pc from 'picocolors';
 import { createRequire } from 'module';
@@ -8,7 +9,16 @@ 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');
+// In dev mode (src/cli.ts), package.json is one level up
+// In production (dist/src/cli.js), package.json is two levels up
+const pkg = (() => {
+    try {
+        return require('../../package.json');
+    }
+    catch {
+        return require('../package.json');
+    }
+})();
 updateNotifier({ pkg }).notify({ isGlobal: true });
 const program = new Command();
 program

package/dist/src/commands/index.js

@@ -6,6 +6,9 @@ import { opencode } from './opencode.js';
 import { work } from './work.js';
 import { code } from './code.js';
 import { autowork } from './autowork.js';
+import { model } from './model.js';
+import { setports } from './setports.js';
+import { queue } from './queue.js';
 export const commands = new Collection();
 commands.set(setpath.data.name, setpath);
 commands.set(projects.data.name, projects);
@@ -14,3 +17,6 @@ commands.set(opencode.data.name, opencode);
 commands.set(work.data.name, work);
 commands.set(code.data.name, code);
 commands.set(autowork.data.name, autowork);
+commands.set(model.data.name, model);
+commands.set(setports.data.name, setports);
+commands.set(queue.data.name, queue);

package/dist/src/commands/model.js

@@ -0,0 +1,85 @@
+import { SlashCommandBuilder, MessageFlags } from 'discord.js';
+import { execSync } from 'node:child_process';
+import * as dataStore from '../services/dataStore.js';
+function getEffectiveChannelId(interaction) {
+    const channel = interaction.channel;
+    if (channel?.isThread()) {
+        return channel.parentId ?? interaction.channelId;
+    }
+    return interaction.channelId;
+}
+export const model = {
+    data: new SlashCommandBuilder()
+        .setName('model')
+        .setDescription('Manage AI models for the current channel')
+        .addSubcommand(subcommand => subcommand
+        .setName('list')
+        .setDescription('List all available models'))
+        .addSubcommand(subcommand => subcommand
+        .setName('set')
+        .setDescription('Set the model to use in this channel')
+        .addStringOption(option => option.setName('name')
+        .setDescription('The model name (e.g., google/gemini-2.0-flash)')
+        .setRequired(true))),
+    async execute(interaction) {
+        const subcommand = interaction.options.getSubcommand();
+        if (subcommand === 'list') {
+            await interaction.deferReply({ flags: MessageFlags.Ephemeral });
+            try {
+                const output = execSync('opencode models', { encoding: 'utf-8' });
+                const models = output.split('\n').filter(m => m.trim());
+                if (models.length === 0) {
+                    await interaction.editReply('No models found.');
+                    return;
+                }
+                // Group models by provider
+                const groups = {};
+                for (const m of models) {
+                    const [provider] = m.split('/');
+                    if (!groups[provider])
+                        groups[provider] = [];
+                    groups[provider].push(m);
+                }
+                let response = '### 🤖 Available Models\n\n';
+                for (const [provider, providerModels] of Object.entries(groups)) {
+                    response += `**${provider}**\n`;
+                    // Limit to 10 models per provider to avoid hitting discord message limit
+                    const displayModels = providerModels.slice(0, 10);
+                    response += displayModels.map(m => `• \`${m}\``).join('\n') + '\n';
+                    if (providerModels.length > 10) {
+                        response += `*...and ${providerModels.length - 10} more*\n`;
+                    }
+                    response += '\n';
+                    if (response.length > 1800) {
+                        await interaction.followUp({ content: response, flags: MessageFlags.Ephemeral });
+                        response = '';
+                    }
+                }
+                if (response) {
+                    await interaction.editReply(response);
+                }
+            }
+            catch (error) {
+                console.error('Failed to list models:', error);
+                await interaction.editReply('❌ Failed to retrieve models from OpenCode CLI.');
+            }
+        }
+        else if (subcommand === 'set') {
+            const modelName = interaction.options.getString('name', true);
+            const channelId = getEffectiveChannelId(interaction);
+            const projectAlias = dataStore.getChannelBinding(channelId);
+            if (!projectAlias) {
+                await interaction.reply({
+                    content: '❌ No project bound to this channel. Use `/use <alias>` first.',
+                    flags: MessageFlags.Ephemeral
+                });
+                return;
+            }
+            dataStore.setChannelModel(channelId, modelName);
+            await interaction.reply({
+                content: `✅ Model for this channel set to \`${modelName}\`.\nSubsequent commands will use this model.`,
+                flags: MessageFlags.Ephemeral
+            });
+        }
+    }
+};