@otto-assistant/otto 0.1.1 → 0.7.15

package/src/commands/share.ts

@@ -0,0 +1,106 @@
+// /share command - Share the current session as a public URL.
+
+import {
+  ChannelType,
+  MessageFlags,
+  type TextChannel,
+  type ThreadChannel,
+} from 'discord.js'
+import type { CommandContext } from './types.js'
+import { getThreadSession } from '../database.js'
+import { initializeOpencodeForDirectory } from '../opencode.js'
+import {
+  resolveWorkingDirectory,
+  SILENT_MESSAGE_FLAGS,
+} from '../discord-utils.js'
+import { createLogger, LogPrefix } from '../logger.js'
+
+const logger = createLogger(LogPrefix.SHARE)
+
+export async function handleShareCommand({
+  command,
+}: CommandContext): Promise<void> {
+  const channel = command.channel
+
+  if (!channel) {
+    await command.reply({
+      content: 'This command can only be used in a channel',
+      flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  const isThread = [
+    ChannelType.PublicThread,
+    ChannelType.PrivateThread,
+    ChannelType.AnnouncementThread,
+  ].includes(channel.type)
+
+  if (!isThread) {
+    await command.reply({
+      content:
+        'This command can only be used in a thread with an active session',
+      flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  const resolved = await resolveWorkingDirectory({
+    channel: channel as TextChannel | ThreadChannel,
+  })
+
+  if (!resolved) {
+    await command.reply({
+      content: 'Could not determine project directory for this channel',
+      flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  const { projectDirectory } = resolved
+
+  const sessionId = await getThreadSession(channel.id)
+
+  if (!sessionId) {
+    await command.reply({
+      content: 'No active session in this thread',
+      flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  const getClient = await initializeOpencodeForDirectory(projectDirectory)
+  if (getClient instanceof Error) {
+    await command.reply({
+      content: `Failed to share session: ${getClient.message}`,
+      flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  try {
+    const response = await getClient().session.share({
+      sessionID: sessionId,
+    })
+
+    if (!response.data?.share?.url) {
+      await command.reply({
+        content: 'Failed to generate share URL',
+        flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+      })
+      return
+    }
+
+    await command.reply({
+      content: `🔗 **Session shared:** ${response.data.share.url}`,
+      flags: SILENT_MESSAGE_FLAGS,
+    })
+    logger.log(`Session ${sessionId} shared: ${response.data.share.url}`)
+  } catch (error) {
+    logger.error('[SHARE] Error:', error)
+    await command.reply({
+      content: `Failed to share session: ${error instanceof Error ? error.message : 'Unknown error'}`,
+      flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+    })
+  }
+}

package/src/commands/tasks.ts

@@ -0,0 +1,293 @@
+// /tasks command — list all scheduled tasks sorted by next run time.
+// Renders a markdown table that the CV2 pipeline auto-formats for Discord,
+// including HTML-backed action buttons for cancellable tasks.
+
+import {
+  ButtonInteraction,
+  ChatInputCommandInteraction,
+  ComponentType,
+  MessageFlags,
+  type APIMessageTopLevelComponent,
+  type APITextDisplayComponent,
+  type InteractionEditReplyOptions,
+} from 'discord.js'
+import {
+  cancelScheduledTask,
+  listScheduledTasks,
+  type ScheduledTask,
+  type ScheduledTaskStatus,
+} from '../database.js'
+import { splitTablesFromMarkdown } from '../format-tables.js'
+import {
+  buildHtmlActionCustomId,
+  cancelHtmlActionsForOwner,
+  registerHtmlAction,
+} from '../html-actions.js'
+import { formatTimeAgo } from './worktrees.js'
+
+function formatTimeUntil(date: Date): string {
+  const diffMs = date.getTime() - Date.now()
+  if (diffMs <= 0) {
+    return 'due now'
+  }
+  const totalSeconds = Math.floor(diffMs / 1000)
+  if (totalSeconds < 60) {
+    return `in ${totalSeconds}s`
+  }
+  const totalMinutes = Math.floor(totalSeconds / 60)
+  if (totalMinutes < 60) {
+    return `in ${totalMinutes}m`
+  }
+  const hours = Math.floor(totalMinutes / 60)
+  const minutes = totalMinutes % 60
+  if (hours < 24) {
+    return minutes > 0 ? `in ${hours}h ${minutes}m` : `in ${hours}h`
+  }
+  const days = Math.floor(hours / 24)
+  const remainingHours = hours % 24
+  return remainingHours > 0 ? `in ${days}d ${remainingHours}h` : `in ${days}d`
+}
+
+function scheduleLabel(task: ScheduledTask): string {
+  if (task.schedule_kind === 'cron') {
+    return task.cron_expr || 'cron'
+  }
+  return 'one-time'
+}
+
+function canCancelTask(task: ScheduledTask): boolean {
+  return task.status === 'planned' || task.status === 'running'
+}
+
+// Escape pipe chars and collapse whitespace so free-text fields don't break
+// GFM table column alignment.
+function sanitizeTableCell(value: string): string {
+  return value.replaceAll('|', '\\|').replace(/\s+/g, ' ').trim()
+}
+
+function buildCancelButtonHtml({ buttonId }: { buttonId: string }): string {
+  return `<button id="${buttonId}" variant="secondary">Delete</button>`
+}
+
+function buildActionCell(task: ScheduledTask): string {
+  if (!canCancelTask(task)) {
+    return '-'
+  }
+  return buildCancelButtonHtml({ buttonId: `cancel-task-${task.id}` })
+}
+
+// Cap rows to avoid exceeding Discord's 40-component CV2 limit.
+// Each cancellable row renders as text + action row + button (~4 components),
+// so 10 rows is a safe ceiling.
+const MAX_TASK_ROWS = 10
+
+function buildTaskTable({
+  tasks,
+}: {
+  tasks: ScheduledTask[]
+}): string {
+  const header = '| ID | Status | Prompt | Schedule | Next Run | Action |'
+  const separator = '|---|---|---|---|---|---|'
+  const rows = tasks.map((task) => {
+    const id = String(task.id)
+    const status = task.status
+    const prompt = sanitizeTableCell(
+      task.prompt_preview.length > 240
+        ? task.prompt_preview.slice(0, 237) + '...'
+        : task.prompt_preview,
+    )
+    const schedule = sanitizeTableCell(scheduleLabel(task))
+    const nextRun = (() => {
+      if (
+        task.status === 'completed' ||
+        task.status === 'cancelled' ||
+        task.status === 'failed'
+      ) {
+        return task.last_run_at ? formatTimeAgo(task.last_run_at) : '-'
+      }
+      return formatTimeUntil(task.next_run_at)
+    })()
+    const action = buildActionCell(task)
+    return `| ${id} | ${status} | ${prompt} | ${schedule} | ${nextRun} | ${action} |`
+  })
+  return [header, separator, ...rows].join('\n')
+}
+
+function getTasksActionOwnerKey({
+  userId,
+  channelId,
+}: {
+  userId: string
+  channelId: string
+}): string {
+  return `tasks:${userId}:${channelId}`
+}
+
+type TasksReplyTarget = {
+  guildId: string
+  userId: string
+  channelId: string
+  showAll: boolean
+  notice?: string
+  editReply: (
+    options: string | InteractionEditReplyOptions,
+  ) => Promise<unknown>
+}
+
+async function renderTasksReply({
+  guildId,
+  userId,
+  channelId,
+  showAll,
+  notice,
+  editReply,
+}: TasksReplyTarget): Promise<void> {
+  const ownerKey = getTasksActionOwnerKey({ userId, channelId })
+  cancelHtmlActionsForOwner(ownerKey)
+
+  const statuses: ScheduledTaskStatus[] | undefined = showAll
+    ? undefined
+    : ['planned', 'running']
+  const allTasks = await listScheduledTasks({ statuses })
+  if (allTasks.length === 0) {
+    const message = notice
+      ? `${notice}\n\nNo scheduled tasks found.`
+      : 'No scheduled tasks found.'
+    const textDisplay: APITextDisplayComponent = {
+      type: ComponentType.TextDisplay,
+      content: message,
+    }
+    await editReply({
+      components: [textDisplay],
+      flags: MessageFlags.IsComponentsV2,
+    })
+    return
+  }
+
+  const tasks = allTasks.slice(0, MAX_TASK_ROWS)
+  const truncatedNotice =
+    allTasks.length > MAX_TASK_ROWS
+      ? `Showing ${MAX_TASK_ROWS}/${allTasks.length} tasks. Use \`otto task list\` for full list.`
+      : undefined
+  const combinedNotice = [notice, truncatedNotice].filter(Boolean).join('\n')
+
+  const cancellableTasksByButtonId = new Map<string, ScheduledTask>()
+  tasks.forEach((task) => {
+    if (!canCancelTask(task)) {
+      return
+    }
+    cancellableTasksByButtonId.set(`cancel-task-${task.id}`, task)
+  })
+
+  const tableMarkdown = buildTaskTable({ tasks })
+  const markdown = combinedNotice
+    ? `${combinedNotice}\n\n${tableMarkdown}`
+    : tableMarkdown
+  const segments = splitTablesFromMarkdown(markdown, {
+    resolveButtonCustomId: ({ button }) => {
+      const task = cancellableTasksByButtonId.get(button.id)
+      if (!task) {
+        return new Error(`No task registered for button ${button.id}`)
+      }
+
+      const actionId = registerHtmlAction({
+        ownerKey,
+        threadId: String(task.id),
+        run: async ({ interaction }) => {
+          await handleCancelTaskAction({
+            interaction,
+            taskId: task.id,
+            showAll,
+          })
+        },
+      })
+      return buildHtmlActionCustomId(actionId)
+    },
+  })
+
+  const components: APIMessageTopLevelComponent[] = segments.flatMap(
+    (segment) => {
+      if (segment.type === 'components') {
+        return segment.components
+      }
+      const textDisplay: APITextDisplayComponent = {
+        type: ComponentType.TextDisplay,
+        content: segment.text,
+      }
+      return [textDisplay]
+    },
+  )
+
+  await editReply({
+    components,
+    flags: MessageFlags.IsComponentsV2,
+  })
+}
+
+async function handleCancelTaskAction({
+  interaction,
+  taskId,
+  showAll,
+}: {
+  interaction: ButtonInteraction
+  taskId: number
+  showAll: boolean
+}): Promise<void> {
+  const guildId = interaction.guildId
+  if (!guildId) {
+    await interaction.editReply({
+      components: [
+        {
+          type: ComponentType.TextDisplay,
+          content: 'This action can only be used in a server.',
+        },
+      ],
+      flags: MessageFlags.IsComponentsV2,
+    })
+    return
+  }
+
+  const cancelled = await cancelScheduledTask(taskId)
+  const notice = cancelled
+    ? `Cancelled task #${taskId}.`
+    : `Task #${taskId} not found or already finalized.`
+
+  await renderTasksReply({
+    guildId,
+    userId: interaction.user.id,
+    channelId: interaction.channelId,
+    showAll,
+    notice,
+    editReply: (options) => {
+      return interaction.editReply(options)
+    },
+  })
+}
+
+export async function handleTasksCommand({
+  command,
+}: {
+  command: ChatInputCommandInteraction
+  appId: string
+}): Promise<void> {
+  const guildId = command.guildId
+  if (!guildId) {
+    await command.reply({
+      content: 'This command can only be used in a server.',
+      flags: MessageFlags.Ephemeral,
+    })
+    return
+  }
+
+  const showAll = command.options.getBoolean('all') ?? false
+  await command.deferReply({ flags: MessageFlags.Ephemeral })
+  await renderTasksReply({
+    guildId,
+    userId: command.user.id,
+    channelId: command.channelId,
+    showAll,
+    editReply: (options) => {
+      return command.editReply(options)
+    },
+  })
+}

package/src/commands/thread-deletion-sync.ts

@@ -0,0 +1,80 @@
+import {
+  ChatInputCommandInteraction,
+  MessageFlags,
+} from 'discord.js'
+import type { APIApplicationCommandOptionChoice } from 'discord.js'
+import {
+  getThreadDeletionSyncMode,
+  resetThreadDeletionSyncMode,
+  setThreadDeletionSyncMode,
+  type ThreadDeletionSyncMode,
+} from '../database.js'
+import { createLogger, LogPrefix } from '../logger.js'
+
+const threadDeletionSyncLogger = createLogger(LogPrefix.CLI)
+
+export const THREAD_DELETION_SYNC_CHOICES: Array<
+  APIApplicationCommandOptionChoice<string>
+> = [
+  { name: 'soft', value: 'soft' },
+  { name: 'hard', value: 'hard' },
+  { name: 'reset', value: 'reset' },
+]
+
+function getModeLabel(mode: ThreadDeletionSyncMode): string {
+  if (mode === 'hard') {
+    return 'hard'
+  }
+  return 'soft'
+}
+
+export async function handleThreadDeletionSyncCommand({
+  command,
+  appId,
+}: {
+  command: ChatInputCommandInteraction
+  appId: string
+}): Promise<void> {
+  const selectedMode = command.options.getString('mode')
+  if (!selectedMode) {
+    const currentMode = await getThreadDeletionSyncMode({ appId })
+    await command.reply({
+      content: `Thread deletion sync mode is **${getModeLabel(currentMode)}**.`,
+      flags: MessageFlags.Ephemeral,
+    })
+    return
+  }
+
+  if (selectedMode === 'reset') {
+    await resetThreadDeletionSyncMode({ appId })
+    threadDeletionSyncLogger.log(
+      `[THREAD_DELETION_SYNC] Reset mode to default for app ${appId}`,
+    )
+    await command.reply({
+      content:
+        'Thread deletion sync mode reset to **soft** (default).\nSoft keeps the OpenCode session and only archives/aborts it.',
+      flags: MessageFlags.Ephemeral,
+    })
+    return
+  }
+
+  if (selectedMode !== 'soft' && selectedMode !== 'hard') {
+    await command.reply({
+      content: `Invalid mode: ${selectedMode}`,
+      flags: MessageFlags.Ephemeral,
+    })
+    return
+  }
+
+  await setThreadDeletionSyncMode({ appId, mode: selectedMode })
+  threadDeletionSyncLogger.log(
+    `[THREAD_DELETION_SYNC] Set mode ${selectedMode} for app ${appId}`,
+  )
+  await command.reply({
+    content:
+      selectedMode === 'hard'
+        ? 'Thread deletion sync mode set to **hard**.\nDeleting a Discord thread will delete the mapped OpenCode session.'
+        : 'Thread deletion sync mode set to **soft**.\nDeleting a Discord thread will archive/abort the mapped OpenCode session.',
+    flags: MessageFlags.Ephemeral,
+  })
+}

package/src/commands/types.ts

@@ -0,0 +1,25 @@
+// Shared types for command handlers.
+
+import type {
+  AutocompleteInteraction,
+  ChatInputCommandInteraction,
+  StringSelectMenuInteraction,
+} from 'discord.js'
+
+export type CommandContext = {
+  command: ChatInputCommandInteraction
+  appId: string
+}
+
+export type CommandHandler = (ctx: CommandContext) => Promise<void>
+
+export type AutocompleteContext = {
+  interaction: AutocompleteInteraction
+  appId: string
+}
+
+export type AutocompleteHandler = (ctx: AutocompleteContext) => Promise<void>
+
+export type SelectMenuHandler = (
+  interaction: StringSelectMenuInteraction,
+) => Promise<void>