@otto-assistant/otto 0.1.1 → 0.7.15

package/dist/channel-management.js

@@ -0,0 +1,259 @@
+// Discord channel and category management.
+// Creates and manages Otto project channels (text + voice pairs),
+// extracts channel metadata from topic tags, and ensures category structure.
+import { ChannelType, } from 'discord.js';
+import fs from 'node:fs';
+import path from 'node:path';
+import { getChannelDirectory, setChannelDirectory, findChannelsByDirectory, } from './database.js';
+import { getProjectsDir } from './config.js';
+import { execAsync } from './worktrees.js';
+import { createLogger, LogPrefix } from './logger.js';
+const logger = createLogger(LogPrefix.CHANNEL);
+// Legacy category names kept for backward-compat lookup on existing servers.
+// New categories are created with the current "Otto" / "Otto Audio" names.
+const CATEGORY_NAME = 'Otto';
+const CATEGORY_NAME_AUDIO = 'Otto Audio';
+const LEGACY_CATEGORY_NAME = 'Kimaki';
+const LEGACY_CATEGORY_NAME_AUDIO = 'Kimaki Audio';
+export async function ensureOttoCategory(guild, botName) {
+    // Skip appending bot name if it's already "otto" to avoid "Otto otto"
+    const isOttoBot = botName?.toLowerCase() === 'otto';
+    const categoryName = botName && !isOttoBot ? `${CATEGORY_NAME} ${botName}` : CATEGORY_NAME;
+    // Legacy names to check when looking up existing categories on older servers
+    const isLegacyKimakiBot = botName?.toLowerCase() === 'otto';
+    const legacyCategoryName = botName && !isLegacyKimakiBot ? `${LEGACY_CATEGORY_NAME} ${botName}` : LEGACY_CATEGORY_NAME;
+    const existingCategory = guild.channels.cache.find((channel) => {
+        if (channel.type !== ChannelType.GuildCategory) {
+            return false;
+        }
+        const name = channel.name.toLowerCase();
+        return (name === categoryName.toLowerCase() ||
+            name === legacyCategoryName.toLowerCase());
+    });
+    if (existingCategory) {
+        return existingCategory;
+    }
+    return guild.channels.create({
+        name: categoryName,
+        type: ChannelType.GuildCategory,
+    });
+}
+// Keep old export name as an alias for any callers that haven't been updated yet
+export const ensureKimakiCategory = ensureOttoCategory;
+export async function ensureOttoAudioCategory(guild, botName) {
+    // Skip appending bot name if it's already "otto" to avoid "Otto Audio otto"
+    const isOttoBot = botName?.toLowerCase() === 'otto';
+    const categoryName = botName && !isOttoBot ? `${CATEGORY_NAME_AUDIO} ${botName}` : CATEGORY_NAME_AUDIO;
+    const isLegacyKimakiBot = botName?.toLowerCase() === 'otto';
+    const legacyCategoryName = botName && !isLegacyKimakiBot
+        ? `${LEGACY_CATEGORY_NAME_AUDIO} ${botName}`
+        : LEGACY_CATEGORY_NAME_AUDIO;
+    const existingCategory = guild.channels.cache.find((channel) => {
+        if (channel.type !== ChannelType.GuildCategory) {
+            return false;
+        }
+        const name = channel.name.toLowerCase();
+        return (name === categoryName.toLowerCase() ||
+            name === legacyCategoryName.toLowerCase());
+    });
+    if (existingCategory) {
+        return existingCategory;
+    }
+    return guild.channels.create({
+        name: categoryName,
+        type: ChannelType.GuildCategory,
+    });
+}
+export const ensureKimakiAudioCategory = ensureOttoAudioCategory;
+export async function createProjectChannels({ guild, projectDirectory, botName, enableVoiceChannels = false, }) {
+    const baseName = path.basename(projectDirectory);
+    const channelName = `${baseName}`
+        .toLowerCase()
+        .replace(/[^a-z0-9-]/g, '-')
+        .slice(0, 100);
+    const ottoCategory = await ensureOttoCategory(guild, botName);
+    const textChannel = await guild.channels.create({
+        name: channelName,
+        type: ChannelType.GuildText,
+        parent: ottoCategory,
+        // Channel configuration is stored in SQLite, not in the topic
+    });
+    await setChannelDirectory({
+        channelId: textChannel.id,
+        directory: projectDirectory,
+        channelType: 'text',
+    });
+    let voiceChannelId = null;
+    if (enableVoiceChannels) {
+        const ottoAudioCategory = await ensureOttoAudioCategory(guild, botName);
+        const voiceChannel = await guild.channels.create({
+            name: channelName,
+            type: ChannelType.GuildVoice,
+            parent: ottoAudioCategory,
+        });
+        await setChannelDirectory({
+            channelId: voiceChannel.id,
+            directory: projectDirectory,
+            channelType: 'voice',
+        });
+        voiceChannelId = voiceChannel.id;
+    }
+    return {
+        textChannelId: textChannel.id,
+        voiceChannelId,
+        channelName,
+    };
+}
+export async function getChannelsWithDescriptions(guild) {
+    const channels = [];
+    const textChannels = guild.channels.cache.filter((channel) => channel.isTextBased());
+    for (const channel of textChannels.values()) {
+        const textChannel = channel;
+        const description = textChannel.topic || null;
+        // Get channel config from database instead of parsing XML from topic
+        const channelConfig = await getChannelDirectory(textChannel.id);
+        channels.push({
+            id: textChannel.id,
+            name: textChannel.name,
+            description,
+            ottoDirectory: channelConfig?.directory,
+        });
+    }
+    return channels;
+}
+const DEFAULT_GITIGNORE = `node_modules/
+dist/
+.env
+.env.*
+!.env.example
+.DS_Store
+tmp/
+*.log
+__pycache__/
+*.pyc
+.venv/
+*.egg-info/
+`;
+const DEFAULT_CHANNEL_TOPIC = 'General channel for misc tasks with Otto. Not connected to a specific OpenCode project or repository.';
+/**
+ * Create (or find) the default "otto" channel for general-purpose tasks.
+ * Channel name is "otto-{botName}" for self-hosted bots, "otto" for gateway.
+ * Directory is <dataDir>/projects/otto (or the legacy <dataDir>/projects/otto
+ * if that already exists on disk), git-initialized with a .gitignore.
+ *
+ * Idempotency: checks the database for an existing channel mapped to the
+ * otto (or legacy otto) projects directory. Also scans guild channels by
+ * name+category as a fallback for channels created before DB mapping existed.
+ */
+export async function createDefaultOttoChannel({ guild, botName, appId, isGatewayMode, }) {
+    // Use the legacy "otto" sub-directory if it already exists on disk so
+    // existing users keep their project history. New installs use "otto".
+    const legacyProjectDirectory = path.join(getProjectsDir(), 'otto');
+    const projectDirectory = fs.existsSync(legacyProjectDirectory)
+        ? legacyProjectDirectory
+        : path.join(getProjectsDir(), 'otto');
+    // Ensure the project directory exists before any DB mapping restoration
+    // or git setup. Custom data dirs may not have <dataDir>/projects created
+    // yet, and later writes assume the full path is present.
+    if (!fs.existsSync(projectDirectory)) {
+        fs.mkdirSync(projectDirectory, { recursive: true });
+        logger.log(`Created default otto directory: ${projectDirectory}`);
+    }
+    // Hydrate guild channels from API so the cache scan is complete
+    try {
+        await guild.channels.fetch();
+    }
+    catch (error) {
+        logger.warn(`Could not fetch guild channels for ${guild.name}: ${error instanceof Error ? error.stack : String(error)}`);
+    }
+    // 1. Check database for existing channel mapped to this directory.
+    // Check ALL mappings (not just the first) since the same directory could
+    // have stale rows from deleted channels or other guilds.
+    const existingMappings = await findChannelsByDirectory({
+        directory: projectDirectory,
+        channelType: 'text',
+    });
+    const mappedChannelInGuild = existingMappings
+        .map((row) => guild.channels.cache.get(row.channel_id))
+        .find((ch) => ch?.type === ChannelType.GuildText);
+    if (mappedChannelInGuild) {
+        logger.log(`Default otto channel already exists: ${mappedChannelInGuild.id}`);
+        return null;
+    }
+    // 2. Fallback: detect existing channel by name+category (handles both the
+    // current "otto"/"otto-*" names and legacy "otto"/"otto-*" names).
+    const ottoCategory = await ensureOttoCategory(guild, botName);
+    const existingByName = guild.channels.cache.find((ch) => {
+        if (ch.type !== ChannelType.GuildText) {
+            return false;
+        }
+        if (ch.parentId !== ottoCategory.id) {
+            return false;
+        }
+        return (ch.name === 'otto' ||
+            ch.name.startsWith('otto-') ||
+            ch.name === 'otto' ||
+            ch.name.startsWith('otto-'));
+    });
+    if (existingByName) {
+        logger.log(`Found existing default channel by name: ${existingByName.id}, restoring DB mapping`);
+        await setChannelDirectory({
+            channelId: existingByName.id,
+            directory: projectDirectory,
+            channelType: 'text',
+            skipIfExists: true,
+        });
+        return null;
+    }
+    // Git init — gracefully skip if git is not installed
+    const gitDir = path.join(projectDirectory, '.git');
+    if (!fs.existsSync(gitDir)) {
+        try {
+            await execAsync('git init', { cwd: projectDirectory, timeout: 10_000 });
+            logger.log(`Initialized git in: ${projectDirectory}`);
+        }
+        catch (error) {
+            logger.warn(`Could not initialize git in ${projectDirectory}: ${error instanceof Error ? error.stack : String(error)}`);
+        }
+    }
+    // Write .gitignore if it doesn't exist
+    const gitignorePath = path.join(projectDirectory, '.gitignore');
+    if (!fs.existsSync(gitignorePath)) {
+        fs.writeFileSync(gitignorePath, DEFAULT_GITIGNORE);
+    }
+    // Channel name: "otto-{botName}" for self-hosted, "otto" for gateway
+    const channelName = (() => {
+        if (isGatewayMode || !botName) {
+            return 'otto';
+        }
+        const sanitized = botName
+            .toLowerCase()
+            .replace(/[^a-z0-9-]/g, '-')
+            .replace(/-+/g, '-')
+            .replace(/^-|-$/g, '');
+        if (!sanitized || sanitized === 'otto') {
+            return 'otto';
+        }
+        return `otto-${sanitized}`.slice(0, 100);
+    })();
+    const textChannel = await guild.channels.create({
+        name: channelName,
+        type: ChannelType.GuildText,
+        parent: ottoCategory,
+        topic: DEFAULT_CHANNEL_TOPIC,
+    });
+    await setChannelDirectory({
+        channelId: textChannel.id,
+        directory: projectDirectory,
+        channelType: 'text',
+    });
+    logger.log(`Created default otto channel: #${channelName} (${textChannel.id})`);
+    return {
+        textChannel,
+        textChannelId: textChannel.id,
+        channelName,
+        projectDirectory,
+    };
+}
+// Keep legacy export name so any unupdated callers still compile
+export const createDefaultKimakiChannel = createDefaultOttoChannel;

package/dist/cli-parsing.test.js

@@ -0,0 +1,142 @@
+// Regression tests for CLI argument parsing around Discord ID string preservation.
+import { describe, expect, test } from 'vitest';
+import { execAsync } from './exec-async.js';
+async function parseWithGoke(argv) {
+    const script = [
+        "import { goke } from 'goke'",
+        'const cli = goke(\'otto\')',
+        "cli.command('send', 'Send a message').option('-c, --channel <channelId>', 'Discord channel ID').option('--thread <threadId>', 'Thread ID').option('--session <sessionId>', 'Session ID').option('--send-at <schedule>', 'Schedule').option('--gateway-platform <platform>', 'Gateway platform').option('--telegram-bot-token <token>', 'Telegram bot token').option('--telegram-chat-id <id>', 'Telegram chat ID')",
+        "cli.command('session archive <threadId>', 'Archive a thread')",
+        "cli.command('session search <query>', 'Search sessions').option('--channel <channelId>', 'Discord channel ID').option('--project <path>', 'Project path')",
+        "cli.command('session export-events-jsonl', 'Export in-memory events to JSONL').option('--session <sessionId>', 'Session ID').option('--out <file>', 'Output path')",
+        "cli.command('add-project', 'Add a project').option('-g, --guild <guildId>', 'Discord guild/server ID')",
+        "cli.command('task delete <id>', 'Delete task')",
+        "cli.command('anthropic-accounts list', 'List stored Anthropic accounts')",
+        "cli.command('anthropic-accounts remove <indexOrEmail>', 'Remove stored Anthropic account')",
+        `const result = cli.parse(${JSON.stringify(argv)}, { run: false })`,
+        'process.stdout.write(JSON.stringify({ args: result.args, options: result.options }))',
+    ].join(';');
+    const { stdout } = await execAsync(`node --input-type=module -e ${JSON.stringify(script)}`, {
+        cwd: import.meta.dirname,
+        timeout: 10_000,
+    });
+    return JSON.parse(stdout);
+}
+async function getHelpOutput() {
+    const script = [
+        "import { goke } from 'goke'",
+        'const stdout = { text: \'\', write(data) { this.text += String(data) } }',
+        "const cli = goke('otto', { stdout })",
+        "cli.command('send', 'Send a message')",
+        "cli.command('anthropic-accounts list', 'List stored Anthropic accounts')",
+        'cli.help()',
+        "cli.parse(['node', 'otto', '--help'], { run: false })",
+        'process.stdout.write(stdout.text)',
+    ].join(';');
+    const { stdout } = await execAsync(`node --input-type=module -e ${JSON.stringify(script)}`, {
+        cwd: import.meta.dirname,
+        timeout: 10_000,
+    });
+    return stdout;
+}
+describe('goke CLI ID parsing', () => {
+    test('keeps large Discord IDs as strings', async () => {
+        const channelId = '1234567890123456789';
+        const threadId = '9876543210987654321';
+        const sessionId = '1111222233334444555';
+        const channelResult = await parseWithGoke(['node', 'otto', 'send', '--channel', channelId]);
+        expect(channelResult.options.channel).toBe(channelId);
+        expect(typeof channelResult.options.channel).toBe('string');
+        const threadResult = await parseWithGoke(['node', 'otto', 'send', '--thread', threadId]);
+        expect(threadResult.options.thread).toBe(threadId);
+        expect(typeof threadResult.options.thread).toBe('string');
+        const sessionResult = await parseWithGoke(['node', 'otto', 'send', '--session', sessionId]);
+        expect(sessionResult.options.session).toBe(sessionId);
+        expect(typeof sessionResult.options.session).toBe('string');
+    });
+    test('preserves leading zeros in Discord IDs', async () => {
+        const guildId = '001230045600789';
+        const result = await parseWithGoke(['node', 'otto', 'add-project', '--guild', guildId]);
+        expect(result.options.guild).toBe(guildId);
+        expect(typeof result.options.guild).toBe('string');
+    });
+    test('keeps session archive thread ID as string', async () => {
+        const threadId = '0098765432109876543';
+        const result = await parseWithGoke(['node', 'otto', 'session', 'archive', threadId]);
+        expect(result.args[0]).toBe(threadId);
+        expect(typeof result.args[0]).toBe('string');
+    });
+    test('keeps session search regex and channel ID as strings', async () => {
+        const channelId = '0012345678901234567';
+        const query = '/error\\s+42/i';
+        const result = await parseWithGoke(['node', 'otto', 'session', 'search', query, '--channel', channelId]);
+        expect(result.args[0]).toBe(query);
+        expect(typeof result.args[0]).toBe('string');
+        expect(result.options.channel).toBe(channelId);
+        expect(typeof result.options.channel).toBe('string');
+    });
+    test('keeps session export options as strings', async () => {
+        const sessionId = '001111222233334444';
+        const outPath = './tmp/session-events.jsonl';
+        const result = await parseWithGoke([
+            'node',
+            'otto',
+            'session',
+            'export-events-jsonl',
+            '--session',
+            sessionId,
+            '--out',
+            outPath,
+        ]);
+        expect(result.options.session).toBe(sessionId);
+        expect(typeof result.options.session).toBe('string');
+        expect(result.options.out).toBe(outPath);
+        expect(typeof result.options.out).toBe('string');
+    });
+    test('keeps --send-at cron string intact', async () => {
+        const cron = '0 9 * * 1';
+        const result = await parseWithGoke(['node', 'otto', 'send', '--send-at', cron]);
+        expect(result.options.sendAt).toBe(cron);
+        expect(typeof result.options.sendAt).toBe('string');
+    });
+    test('keeps gateway onboarding options as strings', async () => {
+        const platform = 'telegram';
+        const botToken = '123456:ABCDEF';
+        const chatId = '-1001234567890';
+        const result = await parseWithGoke([
+            'node',
+            'otto',
+            'send',
+            '--gateway-platform',
+            platform,
+            '--telegram-bot-token',
+            botToken,
+            `--telegram-chat-id=${chatId}`,
+        ]);
+        expect(result.options.gatewayPlatform).toBe(platform);
+        expect(typeof result.options.gatewayPlatform).toBe('string');
+        expect(result.options.telegramBotToken).toBe(botToken);
+        expect(typeof result.options.telegramBotToken).toBe('string');
+        expect(result.options.telegramChatId).toBe(chatId);
+        expect(typeof result.options.telegramChatId).toBe('string');
+    });
+    test('keeps task delete ID as string before validation', async () => {
+        const taskId = '0012345';
+        const result = await parseWithGoke(['node', 'otto', 'task', 'delete', taskId]);
+        expect(result.args[0]).toBe(taskId);
+        expect(typeof result.args[0]).toBe('string');
+    });
+    test('anthropic account remove parses index and email as strings', async () => {
+        const indexResult = await parseWithGoke(['node', 'otto', 'anthropic-accounts', 'remove', '2']);
+        const emailResult = await parseWithGoke(['node', 'otto', 'anthropic-accounts', 'remove', 'user@example.com']);
+        expect(indexResult.args[0]).toBe('2');
+        expect(typeof indexResult.args[0]).toBe('string');
+        expect(emailResult.args[0]).toBe('user@example.com');
+        expect(typeof emailResult.args[0]).toBe('string');
+    });
+    test('anthropic account commands are included in help output', async () => {
+        const stdout = await getHelpOutput();
+        expect(stdout).toContain('send');
+        expect(stdout).toContain('anthropic-accounts');
+    });
+});