@otto-assistant/bridge 0.4.92

package/src/channel-management.ts

@@ -0,0 +1,334 @@
+// Discord channel and category management.
+// Creates and manages Kimaki project channels (text + voice pairs),
+// extracts channel metadata from topic tags, and ensures category structure.
+
+import {
+  ChannelType,
+  type CategoryChannel,
+  type Guild,
+  type TextChannel,
+} 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)
+
+export async function ensureKimakiCategory(
+  guild: Guild,
+  botName?: string,
+): Promise<CategoryChannel> {
+  // Skip appending bot name if it's already "kimaki" to avoid "Kimaki kimaki"
+  const isKimakiBot = botName?.toLowerCase() === 'kimaki'
+  const categoryName = botName && !isKimakiBot ? `Kimaki ${botName}` : 'Kimaki'
+
+  const existingCategory = guild.channels.cache.find(
+    (channel): channel is CategoryChannel => {
+      if (channel.type !== ChannelType.GuildCategory) {
+        return false
+      }
+
+      return channel.name.toLowerCase() === categoryName.toLowerCase()
+    },
+  )
+
+  if (existingCategory) {
+    return existingCategory
+  }
+
+  return guild.channels.create({
+    name: categoryName,
+    type: ChannelType.GuildCategory,
+  })
+}
+
+export async function ensureKimakiAudioCategory(
+  guild: Guild,
+  botName?: string,
+): Promise<CategoryChannel> {
+  // Skip appending bot name if it's already "kimaki" to avoid "Kimaki Audio kimaki"
+  const isKimakiBot = botName?.toLowerCase() === 'kimaki'
+  const categoryName =
+    botName && !isKimakiBot ? `Kimaki Audio ${botName}` : 'Kimaki Audio'
+
+  const existingCategory = guild.channels.cache.find(
+    (channel): channel is CategoryChannel => {
+      if (channel.type !== ChannelType.GuildCategory) {
+        return false
+      }
+
+      return channel.name.toLowerCase() === categoryName.toLowerCase()
+    },
+  )
+
+  if (existingCategory) {
+    return existingCategory
+  }
+
+  return guild.channels.create({
+    name: categoryName,
+    type: ChannelType.GuildCategory,
+  })
+}
+
+export async function createProjectChannels({
+  guild,
+  projectDirectory,
+  botName,
+  enableVoiceChannels = false,
+}: {
+  guild: Guild
+  projectDirectory: string
+  botName?: string
+  enableVoiceChannels?: boolean
+}): Promise<{
+  textChannelId: string
+  voiceChannelId: string | null
+  channelName: string
+}> {
+  const baseName = path.basename(projectDirectory)
+  const channelName = `${baseName}`
+    .toLowerCase()
+    .replace(/[^a-z0-9-]/g, '-')
+    .slice(0, 100)
+
+  const kimakiCategory = await ensureKimakiCategory(guild, botName)
+
+  const textChannel = await guild.channels.create({
+    name: channelName,
+    type: ChannelType.GuildText,
+    parent: kimakiCategory,
+    // Channel configuration is stored in SQLite, not in the topic
+  })
+
+  await setChannelDirectory({
+    channelId: textChannel.id,
+    directory: projectDirectory,
+    channelType: 'text',
+  })
+
+  let voiceChannelId: string | null = null
+
+  if (enableVoiceChannels) {
+    const kimakiAudioCategory = await ensureKimakiAudioCategory(guild, botName)
+
+    const voiceChannel = await guild.channels.create({
+      name: channelName,
+      type: ChannelType.GuildVoice,
+      parent: kimakiAudioCategory,
+    })
+
+    await setChannelDirectory({
+      channelId: voiceChannel.id,
+      directory: projectDirectory,
+      channelType: 'voice',
+    })
+
+    voiceChannelId = voiceChannel.id
+  }
+
+  return {
+    textChannelId: textChannel.id,
+    voiceChannelId,
+    channelName,
+  }
+}
+
+export type ChannelWithTags = {
+  id: string
+  name: string
+  description: string | null
+  kimakiDirectory?: string
+}
+
+export async function getChannelsWithDescriptions(
+  guild: Guild,
+): Promise<ChannelWithTags[]> {
+  const channels: ChannelWithTags[] = []
+
+  const textChannels = guild.channels.cache.filter((channel) =>
+    channel.isTextBased(),
+  )
+
+  for (const channel of textChannels.values()) {
+    const textChannel = channel as TextChannel
+    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,
+      kimakiDirectory: 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 Kimaki. Not connected to a specific OpenCode project or repository.'
+
+/**
+ * Create (or find) the default "kimaki" channel for general-purpose tasks.
+ * Channel name is "kimaki-{botName}" for self-hosted bots, "kimaki" for gateway.
+ * Directory is ~/.kimaki/projects/kimaki, git-initialized with a .gitignore.
+ *
+ * Idempotency: checks the database for an existing channel mapped to the
+ * kimaki projects directory. Also scans guild channels by name+category
+ * as a fallback for channels created before DB mapping existed.
+ */
+export async function createDefaultKimakiChannel({
+  guild,
+  botName,
+  appId,
+  isGatewayMode,
+}: {
+  guild: Guild
+  botName?: string
+  appId: string
+  isGatewayMode: boolean
+}): Promise<{
+  textChannel: TextChannel
+  textChannelId: string
+  channelName: string
+  projectDirectory: string
+} | null> {
+  const projectDirectory = path.join(getProjectsDir(), 'kimaki')
+
+  // Ensure the default kimaki 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 kimaki 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 is TextChannel => ch?.type === ChannelType.GuildText)
+  if (mappedChannelInGuild) {
+    logger.log(`Default kimaki channel already exists: ${mappedChannelInGuild.id}`)
+    return null
+  }
+
+  // 2. Fallback: detect existing channel by name+category
+  const kimakiCategory = await ensureKimakiCategory(guild, botName)
+  const existingByName = guild.channels.cache.find((ch): ch is TextChannel => {
+    if (ch.type !== ChannelType.GuildText) {
+      return false
+    }
+    if (ch.parentId !== kimakiCategory.id) {
+      return false
+    }
+    return ch.name === 'kimaki' || ch.name.startsWith('kimaki-')
+  })
+  if (existingByName) {
+    logger.log(
+      `Found existing default kimaki 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: "kimaki-{botName}" for self-hosted, "kimaki" for gateway
+  const channelName = (() => {
+    if (isGatewayMode || !botName) {
+      return 'kimaki'
+    }
+    const sanitized = botName
+      .toLowerCase()
+      .replace(/[^a-z0-9-]/g, '-')
+      .replace(/-+/g, '-')
+      .replace(/^-|-$/g, '')
+    if (!sanitized || sanitized === 'kimaki') {
+      return 'kimaki'
+    }
+    return `kimaki-${sanitized}`.slice(0, 100)
+  })()
+
+  const textChannel = await guild.channels.create({
+    name: channelName,
+    type: ChannelType.GuildText,
+    parent: kimakiCategory,
+    topic: DEFAULT_CHANNEL_TOPIC,
+  })
+
+  await setChannelDirectory({
+    channelId: textChannel.id,
+    directory: projectDirectory,
+    channelType: 'text',
+  })
+
+  logger.log(`Created default kimaki channel: #${channelName} (${textChannel.id})`)
+
+  return {
+    textChannel,
+    textChannelId: textChannel.id,
+    channelName,
+    projectDirectory,
+  }
+}

package/src/cli-parsing.test.ts

@@ -0,0 +1,195 @@
+// Regression tests for CLI argument parsing around Discord ID string preservation.
+import { describe, expect, test } from 'vitest'
+import { goke } from 'goke'
+
+function createCliForIdParsing() {
+  const cli = goke('kimaki')
+
+  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')
+
+  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').hidden()
+  cli.command('anthropic-accounts remove <index>', 'Remove stored Anthropic account').hidden()
+
+  return cli
+}
+
+describe('goke CLI ID parsing', () => {
+  test('keeps large Discord IDs as strings', () => {
+    const cli = createCliForIdParsing()
+    const channelId = '1234567890123456789'
+    const threadId = '9876543210987654321'
+    const sessionId = '1111222233334444555'
+
+    const channelResult = cli.parse(
+      ['node', 'kimaki', 'send', '--channel', channelId],
+      {
+        run: false,
+      },
+    )
+    expect(channelResult.options.channel).toBe(channelId)
+    expect(typeof channelResult.options.channel).toBe('string')
+
+    const threadResult = cli.parse(
+      ['node', 'kimaki', 'send', '--thread', threadId],
+      { run: false },
+    )
+    expect(threadResult.options.thread).toBe(threadId)
+    expect(typeof threadResult.options.thread).toBe('string')
+
+    const sessionResult = cli.parse(
+      ['node', 'kimaki', 'send', '--session', sessionId],
+      {
+        run: false,
+      },
+    )
+    expect(sessionResult.options.session).toBe(sessionId)
+    expect(typeof sessionResult.options.session).toBe('string')
+  })
+
+  test('preserves leading zeros in Discord IDs', () => {
+    const cli = createCliForIdParsing()
+    const guildId = '001230045600789'
+
+    const result = cli.parse(
+      ['node', 'kimaki', 'add-project', '--guild', guildId],
+      { run: false },
+    )
+
+    expect(result.options.guild).toBe(guildId)
+    expect(typeof result.options.guild).toBe('string')
+  })
+
+  test('keeps session archive thread ID as string', () => {
+    const cli = createCliForIdParsing()
+    const threadId = '0098765432109876543'
+
+    const result = cli.parse(
+      ['node', 'kimaki', 'session', 'archive', threadId],
+      {
+        run: false,
+      },
+    )
+
+    expect(result.args[0]).toBe(threadId)
+    expect(typeof result.args[0]).toBe('string')
+  })
+
+  test('keeps session search regex and channel ID as strings', () => {
+    const cli = createCliForIdParsing()
+    const channelId = '0012345678901234567'
+    const query = '/error\\s+42/i'
+
+    const result = cli.parse(
+      ['node', 'kimaki', 'session', 'search', query, '--channel', channelId],
+      {
+        run: false,
+      },
+    )
+
+    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', () => {
+    const cli = createCliForIdParsing()
+    const sessionId = '001111222233334444'
+    const outPath = './tmp/session-events.jsonl'
+
+    const result = cli.parse(
+      [
+        'node',
+        'kimaki',
+        'session',
+        'export-events-jsonl',
+        '--session',
+        sessionId,
+        '--out',
+        outPath,
+      ],
+      {
+        run: false,
+      },
+    )
+
+    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', () => {
+    const cli = createCliForIdParsing()
+    const cron = '0 9 * * 1'
+
+    const result = cli.parse(['node', 'kimaki', 'send', '--send-at', cron], {
+      run: false,
+    })
+
+    expect(result.options.sendAt).toBe(cron)
+    expect(typeof result.options.sendAt).toBe('string')
+  })
+
+  test('keeps task delete ID as string before validation', () => {
+    const cli = createCliForIdParsing()
+    const taskId = '0012345'
+
+    const result = cli.parse(['node', 'kimaki', 'task', 'delete', taskId], {
+      run: false,
+    })
+
+    expect(result.args[0]).toBe(taskId)
+    expect(typeof result.args[0]).toBe('string')
+  })
+
+  test('hidden anthropic account commands still parse', () => {
+    const cli = createCliForIdParsing()
+
+    const result = cli.parse(
+      ['node', 'kimaki', 'anthropic-accounts', 'remove', '2'],
+      { run: false },
+    )
+
+    expect(result.args[0]).toBe('2')
+    expect(typeof result.args[0]).toBe('string')
+  })
+
+  test('hidden anthropic account commands are excluded from help output', () => {
+    const stdout = {
+      text: '',
+      write(data: string | Uint8Array) {
+        this.text += String(data)
+      },
+    }
+
+    const cli = goke('kimaki', { stdout: stdout as never })
+    cli.command('send', 'Send a message')
+    cli.command('anthropic-accounts list', 'List stored Anthropic accounts').hidden()
+    cli.help()
+    cli.parse(['node', 'kimaki', '--help'], { run: false })
+
+    expect(stdout.text).toContain('send')
+    expect(stdout.text).not.toContain('anthropic-accounts')
+  })
+})