disunday 1.0.0

package/dist/commands/user-command.js

@@ -0,0 +1,135 @@
+// User-defined OpenCode command handler.
+// Handles slash commands that map to user-configured commands in opencode.json.
+import { ChannelType } from 'discord.js';
+import { handleOpencodeSession } from '../session-handler.js';
+import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js';
+import { createLogger, LogPrefix } from '../logger.js';
+import { getDatabase, getChannelDirectory } from '../database.js';
+import fs from 'node:fs';
+const userCommandLogger = createLogger(LogPrefix.USER_CMD);
+export const handleUserCommand = async ({ command, appId }) => {
+    const discordCommandName = command.commandName;
+    // Strip the -cmd suffix to get the actual OpenCode command name
+    const commandName = discordCommandName.replace(/-cmd$/, '');
+    const args = command.options.getString('arguments') || '';
+    userCommandLogger.log(`Executing /${commandName} (from /${discordCommandName}) with args: ${args}`);
+    const channel = command.channel;
+    userCommandLogger.log(`Channel info: type=${channel?.type}, id=${channel?.id}, isNull=${channel === null}`);
+    const isThread = channel &&
+        [ChannelType.PublicThread, ChannelType.PrivateThread, ChannelType.AnnouncementThread].includes(channel.type);
+    const isTextChannel = channel?.type === ChannelType.GuildText;
+    if (!channel || (!isTextChannel && !isThread)) {
+        await command.reply({
+            content: 'This command can only be used in text channels or threads',
+            ephemeral: true,
+        });
+        return;
+    }
+    let projectDirectory;
+    let channelAppId;
+    let textChannel = null;
+    let thread = null;
+    if (isThread) {
+        // Running in an existing thread - get project directory from parent channel
+        thread = channel;
+        textChannel = thread.parent;
+        // Verify this thread has an existing session
+        const row = getDatabase()
+            .prepare('SELECT session_id FROM thread_sessions WHERE thread_id = ?')
+            .get(thread.id);
+        if (!row) {
+            await command.reply({
+                content: 'This thread does not have an active session. Use this command in a project channel to create a new thread.',
+                ephemeral: true,
+            });
+            return;
+        }
+        if (textChannel) {
+            const channelConfig = getChannelDirectory(textChannel.id);
+            projectDirectory = channelConfig?.directory;
+            channelAppId = channelConfig?.appId || undefined;
+        }
+    }
+    else {
+        // Running in a text channel - will create a new thread
+        textChannel = channel;
+        const channelConfig = getChannelDirectory(textChannel.id);
+        projectDirectory = channelConfig?.directory;
+        channelAppId = channelConfig?.appId || undefined;
+    }
+    if (channelAppId && channelAppId !== appId) {
+        await command.reply({
+            content: 'This channel is not configured for this bot',
+            ephemeral: true,
+        });
+        return;
+    }
+    if (!projectDirectory) {
+        await command.reply({
+            content: 'This channel is not configured with a project directory',
+            ephemeral: true,
+        });
+        return;
+    }
+    if (!fs.existsSync(projectDirectory)) {
+        await command.reply({
+            content: `Directory does not exist: ${projectDirectory}`,
+            ephemeral: true,
+        });
+        return;
+    }
+    await command.deferReply({ ephemeral: false });
+    try {
+        // Use the dedicated session.command API instead of formatting as text prompt
+        const commandPayload = { name: commandName, arguments: args };
+        if (isThread && thread) {
+            // Running in existing thread - just send the command
+            await command.editReply(`Running /${commandName}...`);
+            await handleOpencodeSession({
+                prompt: '', // Not used when command is set
+                thread,
+                projectDirectory,
+                channelId: textChannel?.id,
+                command: commandPayload,
+            });
+        }
+        else if (textChannel) {
+            // Running in text channel - create a new thread
+            const starterMessage = await textChannel.send({
+                content: `**/${commandName}**${args ? ` ${args.slice(0, 200)}${args.length > 200 ? '…' : ''}` : ''}`,
+                flags: SILENT_MESSAGE_FLAGS,
+            });
+            const threadName = `/${commandName} ${args.slice(0, 80)}${args.length > 80 ? '…' : ''}`;
+            const newThread = await starterMessage.startThread({
+                name: threadName.slice(0, 100),
+                autoArchiveDuration: 1440,
+                reason: `OpenCode command: ${commandName}`,
+            });
+            // Add user to thread so it appears in their sidebar
+            await newThread.members.add(command.user.id);
+            await command.editReply(`Started /${commandName} in ${newThread.toString()}`);
+            await handleOpencodeSession({
+                prompt: '', // Not used when command is set
+                thread: newThread,
+                projectDirectory,
+                channelId: textChannel.id,
+                command: commandPayload,
+            });
+        }
+    }
+    catch (error) {
+        userCommandLogger.error(`Error executing /${commandName}:`, error);
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        if (command.deferred) {
+            await command.editReply({
+                content: `Failed to execute /${commandName}: ${errorMessage}`,
+            });
+        }
+        else {
+            await command.reply({
+                content: `Failed to execute /${commandName}: ${errorMessage}`,
+                ephemeral: true,
+            });
+        }
+    }
+};

package/dist/commands/verbosity.js

@@ -0,0 +1,59 @@
+// /verbosity command.
+// Sets the output verbosity level for sessions in a channel.
+// 'tools-and-text' (default): shows all output including tool executions
+// 'text-only': only shows text responses (⬥ diamond parts)
+import { ChatInputCommandInteraction, ChannelType } from 'discord.js';
+import { getChannelVerbosity, setChannelVerbosity } from '../database.js';
+import { createLogger, LogPrefix } from '../logger.js';
+const verbosityLogger = createLogger(LogPrefix.VERBOSITY);
+/**
+ * Handle the /verbosity slash command.
+ * Sets output verbosity for the channel (applies immediately, even mid-session).
+ */
+export async function handleVerbosityCommand({ command, appId, }) {
+    verbosityLogger.log('[VERBOSITY] Command called');
+    const channel = command.channel;
+    if (!channel) {
+        await command.reply({
+            content: 'Could not determine channel.',
+            ephemeral: true,
+        });
+        return;
+    }
+    // Get the parent channel ID (for threads, use parent; for text channels, use self)
+    const channelId = (() => {
+        if (channel.type === ChannelType.GuildText) {
+            return channel.id;
+        }
+        if (channel.type === ChannelType.PublicThread ||
+            channel.type === ChannelType.PrivateThread ||
+            channel.type === ChannelType.AnnouncementThread) {
+            return channel.parentId || channel.id;
+        }
+        return channel.id;
+    })();
+    const level = command.options.getString('level', true);
+    const currentLevel = getChannelVerbosity(channelId);
+    if (currentLevel === level) {
+        await command.reply({
+            content: `Verbosity is already set to **${level}** for this channel.`,
+            ephemeral: true,
+        });
+        return;
+    }
+    setChannelVerbosity(channelId, level);
+    verbosityLogger.log(`[VERBOSITY] Set channel ${channelId} to ${level}`);
+    const description = (() => {
+        if (level === 'text-only') {
+            return 'Only text responses will be shown. Tool executions, status messages, and thinking will be hidden.';
+        }
+        if (level === 'text-and-essential-tools') {
+            return 'Text responses and essential tools (edits, custom MCP tools) will be shown. Read, search, and navigation tools will be hidden.';
+        }
+        return 'All output will be shown, including tool executions and status messages.';
+    })();
+    await command.reply({
+        content: `Verbosity set to **${level}** for this channel.\n${description}\nThis is a per-channel setting and applies immediately, including any active sessions.`,
+        ephemeral: true,
+    });
+}

package/dist/commands/worktree-settings.js

@@ -0,0 +1,50 @@
+// /toggle-worktrees command.
+// Allows per-channel opt-in for automatic worktree creation,
+// as an alternative to the global --use-worktrees CLI flag.
+import { ChatInputCommandInteraction, ChannelType } from 'discord.js';
+import { getChannelWorktreesEnabled, setChannelWorktreesEnabled } from '../database.js';
+import { getDisundayMetadata } from '../discord-utils.js';
+import { createLogger, LogPrefix } from '../logger.js';
+const worktreeSettingsLogger = createLogger(LogPrefix.WORKTREE);
+/**
+ * Handle the /toggle-worktrees slash command.
+ * Toggles automatic worktree creation for new sessions in this channel.
+ */
+export async function handleToggleWorktreesCommand({ command, appId, }) {
+    worktreeSettingsLogger.log('[TOGGLE_WORKTREES] Command called');
+    const channel = command.channel;
+    if (!channel || channel.type !== ChannelType.GuildText) {
+        await command.reply({
+            content: 'This command can only be used in text channels (not threads).',
+            ephemeral: true,
+        });
+        return;
+    }
+    const textChannel = channel;
+    const metadata = getDisundayMetadata(textChannel);
+    if (metadata.channelAppId && metadata.channelAppId !== appId) {
+        await command.reply({
+            content: 'This channel is configured for a different bot.',
+            ephemeral: true,
+        });
+        return;
+    }
+    if (!metadata.projectDirectory) {
+        await command.reply({
+            content: 'This channel is not configured with a project directory.\nUse `/add-project` to set up this channel.',
+            ephemeral: true,
+        });
+        return;
+    }
+    const wasEnabled = getChannelWorktreesEnabled(textChannel.id);
+    const nextEnabled = !wasEnabled;
+    setChannelWorktreesEnabled(textChannel.id, nextEnabled);
+    const nextLabel = nextEnabled ? 'enabled' : 'disabled';
+    worktreeSettingsLogger.log(`[TOGGLE_WORKTREES] ${nextLabel.toUpperCase()} for channel ${textChannel.id}`);
+    await command.reply({
+        content: nextEnabled
+            ? `Worktrees **enabled** for this channel.\n\nNew sessions started from messages in **#${textChannel.name}** will now automatically create git worktrees.\n\nNew setting for **#${textChannel.name}**: **enabled**.`
+            : `Worktrees **disabled** for this channel.\n\nNew sessions started from messages in **#${textChannel.name}** will use the main project directory.\n\nNew setting for **#${textChannel.name}**: **disabled**.`,
+        ephemeral: true,
+    });
+}

package/dist/commands/worktree.js

@@ -0,0 +1,288 @@
+// Worktree management command: /new-worktree
+// Uses OpenCode SDK v2 to create worktrees with disunday- prefix
+// Creates thread immediately, then worktree in background so user can type
+import { ChannelType } from 'discord.js';
+import fs from 'node:fs';
+import { createPendingWorktree, setWorktreeReady, setWorktreeError, getChannelDirectory, getThreadWorktree, } from '../database.js';
+import { initializeOpencodeForDirectory, getOpencodeClientV2 } from '../opencode.js';
+import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js';
+import { createLogger, LogPrefix } from '../logger.js';
+import { createWorktreeWithSubmodules, captureGitDiff } from '../worktree-utils.js';
+import { WORKTREE_PREFIX } from './merge-worktree.js';
+import * as errore from 'errore';
+const logger = createLogger(LogPrefix.WORKTREE);
+class WorktreeError extends Error {
+    constructor(message, options) {
+        super(message, options);
+        this.name = 'WorktreeError';
+    }
+}
+/**
+ * Format worktree name: lowercase, spaces to dashes, remove special chars, add opencode/disunday- prefix.
+ * "My Feature" → "opencode/disunday-my-feature"
+ * Returns empty string if no valid name can be extracted.
+ */
+export function formatWorktreeName(name) {
+    const formatted = name
+        .toLowerCase()
+        .trim()
+        .replace(/\s+/g, '-')
+        .replace(/[^a-z0-9-]/g, '');
+    if (!formatted) {
+        return '';
+    }
+    return `opencode/disunday-${formatted}`;
+}
+/**
+ * Derive worktree name from thread name.
+ * Handles existing "⬦ worktree: opencode/disunday-name" format or uses thread name directly.
+ */
+function deriveWorktreeNameFromThread(threadName) {
+    // Handle existing "⬦ worktree: opencode/disunday-name" format
+    const worktreeMatch = threadName.match(/worktree:\s*(.+)$/i);
+    const extractedName = worktreeMatch?.[1]?.trim();
+    if (extractedName) {
+        // If already has opencode/disunday- prefix, return as is
+        if (extractedName.startsWith('opencode/disunday-')) {
+            return extractedName;
+        }
+        return formatWorktreeName(extractedName);
+    }
+    // Use thread name directly
+    return formatWorktreeName(threadName);
+}
+/**
+ * Get project directory from database.
+ */
+function getProjectDirectoryFromChannel(channel, appId) {
+    const channelConfig = getChannelDirectory(channel.id);
+    if (!channelConfig) {
+        return new WorktreeError('This channel is not configured with a project directory');
+    }
+    if (channelConfig.appId && channelConfig.appId !== appId) {
+        return new WorktreeError('This channel is not configured for this bot');
+    }
+    if (!fs.existsSync(channelConfig.directory)) {
+        return new WorktreeError(`Directory does not exist: ${channelConfig.directory}`);
+    }
+    return channelConfig.directory;
+}
+/**
+ * Create worktree in background and update starter message when done.
+ * If diff is provided, it's applied during worktree creation (before submodule init).
+ */
+async function createWorktreeInBackground({ thread, starterMessage, worktreeName, projectDirectory, clientV2, diff, }) {
+    // Create worktree using SDK v2, apply diff, then init submodules
+    logger.log(`Creating worktree "${worktreeName}" for project ${projectDirectory}`);
+    const worktreeResult = await createWorktreeWithSubmodules({
+        clientV2,
+        directory: projectDirectory,
+        name: worktreeName,
+        diff,
+    });
+    if (worktreeResult instanceof Error) {
+        const errorMsg = worktreeResult.message;
+        logger.error('[NEW-WORKTREE] Error:', worktreeResult);
+        setWorktreeError({ threadId: thread.id, errorMessage: errorMsg });
+        await starterMessage.edit(`🌳 **Worktree: ${worktreeName}**\n❌ ${errorMsg}`);
+        return;
+    }
+    // Success - update database and edit starter message
+    setWorktreeReady({ threadId: thread.id, worktreeDirectory: worktreeResult.directory });
+    const diffStatus = diff ? (worktreeResult.diffApplied ? '\n✅ Changes applied' : '\n⚠️ Failed to apply changes') : '';
+    await starterMessage.edit(`🌳 **Worktree: ${worktreeName}**\n` +
+        `📁 \`${worktreeResult.directory}\`\n` +
+        `🌿 Branch: \`${worktreeResult.branch}\`` +
+        diffStatus);
+}
+export async function handleNewWorktreeCommand({ command, appId, }) {
+    await command.deferReply({ ephemeral: false });
+    const channel = command.channel;
+    if (!channel) {
+        await command.editReply('Cannot determine channel');
+        return;
+    }
+    const isThread = channel.type === ChannelType.PublicThread || channel.type === ChannelType.PrivateThread;
+    // Handle command in existing thread - attach worktree to this thread
+    if (isThread) {
+        await handleWorktreeInThread({ command, appId, thread: channel });
+        return;
+    }
+    // Handle command in text channel - create new thread with worktree (existing behavior)
+    if (channel.type !== ChannelType.GuildText) {
+        await command.editReply('This command can only be used in text channels or threads');
+        return;
+    }
+    const rawName = command.options.getString('name');
+    if (!rawName) {
+        await command.editReply('Name is required when creating a worktree from a text channel. Use `/new-worktree name:my-feature`');
+        return;
+    }
+    const worktreeName = formatWorktreeName(rawName);
+    if (!worktreeName) {
+        await command.editReply('Invalid worktree name. Please use letters, numbers, and spaces.');
+        return;
+    }
+    const textChannel = channel;
+    const projectDirectory = getProjectDirectoryFromChannel(textChannel, appId);
+    if (errore.isError(projectDirectory)) {
+        await command.editReply(projectDirectory.message);
+        return;
+    }
+    // Initialize opencode and check if worktree already exists
+    const getClient = await initializeOpencodeForDirectory(projectDirectory);
+    if (errore.isError(getClient)) {
+        await command.editReply(`Failed to initialize OpenCode: ${getClient.message}`);
+        return;
+    }
+    const clientV2 = getOpencodeClientV2(projectDirectory);
+    if (!clientV2) {
+        await command.editReply('Failed to get OpenCode client');
+        return;
+    }
+    // Check if worktree with this name already exists
+    // SDK returns array of directory paths like "~/.opencode/worktree/abc/disunday-my-feature"
+    const listResult = await errore.tryAsync({
+        try: async () => {
+            const response = await clientV2.worktree.list({ directory: projectDirectory });
+            return response.data || [];
+        },
+        catch: (e) => new WorktreeError('Failed to list worktrees', { cause: e }),
+    });
+    if (errore.isError(listResult)) {
+        await command.editReply(listResult.message);
+        return;
+    }
+    // Check if any worktree path ends with our name
+    const existingWorktree = listResult.find((dir) => dir.endsWith(`/${worktreeName}`));
+    if (existingWorktree) {
+        await command.editReply(`Worktree \`${worktreeName}\` already exists at \`${existingWorktree}\``);
+        return;
+    }
+    // Create thread immediately so user can start typing
+    const result = await errore.tryAsync({
+        try: async () => {
+            const starterMessage = await textChannel.send({
+                content: `🌳 **Creating worktree: ${worktreeName}**\n⏳ Setting up...`,
+                flags: SILENT_MESSAGE_FLAGS,
+            });
+            const thread = await starterMessage.startThread({
+                name: `${WORKTREE_PREFIX}worktree: ${worktreeName}`,
+                autoArchiveDuration: 1440,
+                reason: 'Worktree session',
+            });
+            // Add user to thread so it appears in their sidebar
+            await thread.members.add(command.user.id);
+            return { thread, starterMessage };
+        },
+        catch: (e) => new WorktreeError('Failed to create thread', { cause: e }),
+    });
+    if (errore.isError(result)) {
+        logger.error('[NEW-WORKTREE] Error:', result.cause);
+        await command.editReply(result.message);
+        return;
+    }
+    const { thread, starterMessage } = result;
+    // Store pending worktree in database
+    createPendingWorktree({
+        threadId: thread.id,
+        worktreeName,
+        projectDirectory,
+    });
+    await command.editReply(`Creating worktree in ${thread.toString()}`);
+    // Create worktree in background (don't await)
+    createWorktreeInBackground({
+        thread,
+        starterMessage,
+        worktreeName,
+        projectDirectory,
+        clientV2,
+    }).catch((e) => {
+        logger.error('[NEW-WORKTREE] Background error:', e);
+    });
+}
+/**
+ * Handle /new-worktree when called inside an existing thread.
+ * Attaches a worktree to the current thread, using thread name if no name provided.
+ */
+async function handleWorktreeInThread({ command, appId, thread, }) {
+    // Error if thread already has a worktree
+    if (getThreadWorktree(thread.id)) {
+        await command.editReply('This thread already has a worktree attached.');
+        return;
+    }
+    // Get worktree name from parameter or derive from thread name
+    const rawName = command.options.getString('name');
+    const worktreeName = rawName ? formatWorktreeName(rawName) : deriveWorktreeNameFromThread(thread.name);
+    if (!worktreeName) {
+        await command.editReply('Invalid worktree name. Please provide a name or rename the thread.');
+        return;
+    }
+    // Get parent channel for project directory
+    const parent = thread.parent;
+    if (!parent || parent.type !== ChannelType.GuildText) {
+        await command.editReply('Cannot determine parent channel');
+        return;
+    }
+    const projectDirectory = getProjectDirectoryFromChannel(parent, appId);
+    if (errore.isError(projectDirectory)) {
+        await command.editReply(projectDirectory.message);
+        return;
+    }
+    // Initialize opencode
+    const getClient = await initializeOpencodeForDirectory(projectDirectory);
+    if (errore.isError(getClient)) {
+        await command.editReply(`Failed to initialize OpenCode: ${getClient.message}`);
+        return;
+    }
+    const clientV2 = getOpencodeClientV2(projectDirectory);
+    if (!clientV2) {
+        await command.editReply('Failed to get OpenCode client');
+        return;
+    }
+    // Check if worktree with this name already exists
+    const listResult = await errore.tryAsync({
+        try: async () => {
+            const response = await clientV2.worktree.list({ directory: projectDirectory });
+            return response.data || [];
+        },
+        catch: (e) => new WorktreeError('Failed to list worktrees', { cause: e }),
+    });
+    if (errore.isError(listResult)) {
+        await command.editReply(listResult.message);
+        return;
+    }
+    const existingWorktreePath = listResult.find((dir) => dir.endsWith(`/${worktreeName}`));
+    if (existingWorktreePath) {
+        await command.editReply(`Worktree \`${worktreeName}\` already exists at \`${existingWorktreePath}\``);
+        return;
+    }
+    // Capture git diff from project directory before creating worktree.
+    // This allows transferring uncommitted changes to the new worktree.
+    const diff = await captureGitDiff(projectDirectory);
+    const hasDiff = diff && (diff.staged || diff.unstaged);
+    // Store pending worktree in database for this existing thread
+    createPendingWorktree({
+        threadId: thread.id,
+        worktreeName,
+        projectDirectory,
+    });
+    // Send status message in thread
+    const diffNote = hasDiff ? '\n📋 Will transfer uncommitted changes' : '';
+    const statusMessage = await thread.send({
+        content: `🌳 **Creating worktree: ${worktreeName}**\n⏳ Setting up...${diffNote}`,
+        flags: SILENT_MESSAGE_FLAGS,
+    });
+    await command.editReply(`Creating worktree \`${worktreeName}\` for this thread...`);
+    // Create worktree in background, passing diff to apply after creation
+    createWorktreeInBackground({
+        thread,
+        starterMessage: statusMessage,
+        worktreeName,
+        projectDirectory,
+        clientV2,
+        diff,
+    }).catch((e) => {
+        logger.error('[NEW-WORKTREE] Background error:', e);
+    });
+}

package/dist/config.js

@@ -0,0 +1,139 @@
+// Runtime configuration for Disunday bot.
+// Stores data directory path and provides accessors for other modules.
+// Must be initialized before database or other path-dependent modules are used.
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+const DEFAULT_DATA_DIR = path.join(os.homedir(), '.disunday');
+let dataDir = null;
+/**
+ * Get the data directory path.
+ * Falls back to ~/.disunday if not explicitly set.
+ */
+export function getDataDir() {
+    if (!dataDir) {
+        dataDir = DEFAULT_DATA_DIR;
+    }
+    return dataDir;
+}
+/**
+ * Set the data directory path.
+ * Creates the directory if it doesn't exist.
+ * Must be called before any database or path-dependent operations.
+ */
+export function setDataDir(dir) {
+    const resolvedDir = path.resolve(dir);
+    if (!fs.existsSync(resolvedDir)) {
+        fs.mkdirSync(resolvedDir, { recursive: true });
+    }
+    dataDir = resolvedDir;
+}
+/**
+ * Get the projects directory path (for /create-new-project command).
+ * Returns <dataDir>/projects
+ */
+export function getProjectsDir() {
+    return path.join(getDataDir(), 'projects');
+}
+let defaultVerbosity = 'tools-and-text';
+export function getDefaultVerbosity() {
+    return defaultVerbosity;
+}
+export function setDefaultVerbosity(level) {
+    defaultVerbosity = level;
+}
+const DEFAULT_LOCK_PORT = 29988;
+/**
+ * Derive a lock port from the data directory path.
+ * Returns 29988 for the default ~/.disunday directory (backwards compatible).
+ * For custom data dirs, uses a hash to generate a port in the range 30000-39999.
+ */
+export function getLockPort() {
+    const dir = getDataDir();
+    // Use original port for default data dir (backwards compatible)
+    if (dir === DEFAULT_DATA_DIR) {
+        return DEFAULT_LOCK_PORT;
+    }
+    // Hash-based port for custom data dirs
+    let hash = 0;
+    for (let i = 0; i < dir.length; i++) {
+        const char = dir.charCodeAt(i);
+        hash = (hash << 5) - hash + char;
+        hash = hash & hash; // Convert to 32bit integer
+    }
+    // Map to port range 30000-39999
+    return 30000 + (Math.abs(hash) % 10000);
+}
+// Bash command whitelist for OpenCode sessions
+// Default allowed bash commands for security
+const DEFAULT_BASH_WHITELIST = [
+    'git',
+    'npm',
+    'pnpm',
+    'bun',
+    'node',
+    'npx',
+    'bunx',
+    'cat',
+    'ls',
+    'pwd',
+    'echo',
+    'grep',
+    'find',
+    'head',
+    'tail',
+    'wc',
+    'tree',
+    'which',
+    'env',
+    'printenv',
+    'date',
+    'uname',
+    'mkdir',
+    'touch',
+    'cp',
+    'mv',
+    'rm', // file operations
+    'curl',
+    'wget', // network
+    'tsc',
+    'eslint',
+    'prettier',
+    'vitest',
+    'jest', // dev tools
+];
+let bashWhitelist = DEFAULT_BASH_WHITELIST;
+export function getBashWhitelist() {
+    return bashWhitelist;
+}
+export function setBashWhitelist(whitelist) {
+    bashWhitelist = whitelist;
+}
+const DEFAULT_RATE_LIMIT = {
+    messagesPerMinute: 10,
+    commandsPerMinute: 20,
+};
+let rateLimitConfig = DEFAULT_RATE_LIMIT;
+export function getRateLimitConfig() {
+    return rateLimitConfig;
+}
+export function setRateLimitConfig(config) {
+    rateLimitConfig = config;
+}
+const DEFAULT_FILE_VALIDATION = {
+    maxFileSizeBytes: 10 * 1024 * 1024, // 10MB
+    allowedMimeTypes: [
+        'image/png',
+        'image/jpeg',
+        'image/gif',
+        'image/webp',
+        'application/pdf',
+    ],
+};
+let fileValidationConfig = DEFAULT_FILE_VALIDATION;
+export function getFileValidationConfig() {
+    return fileValidationConfig;
+}
+export function setFileValidationConfig(config) {
+    fileValidationConfig = config;
+}