@otto-assistant/bridge 0.4.92

package/src/ipc-polling.ts

@@ -0,0 +1,326 @@
+// IPC polling bridge between the opencode plugin and the Discord bot.
+// The plugin inserts rows into ipc_requests (via Prisma). This module polls
+// that table, claims pending rows atomically, and dispatches them by type.
+// Replaces the old HTTP lock-server approach with DB-based IPC.
+
+import * as errore from 'errore'
+import { createTaggedError } from 'errore'
+import type { Client } from 'discord.js'
+import {
+  claimPendingIpcRequests,
+  completeIpcRequest,
+  cancelAllPendingIpcRequests,
+  cancelStaleProcessingRequests,
+} from './database.js'
+import { showFileUploadButton } from './commands/file-upload.js'
+import { queueActionButtonsRequest } from './commands/action-buttons.js'
+import type { ActionButtonColor } from './commands/action-buttons.js'
+import { createLogger, LogPrefix } from './logger.js'
+import { notifyError } from './sentry.js'
+
+const ipcLogger = createLogger(LogPrefix.IPC)
+
+// ── Tagged errors ────────────────────────────────────────────────────────
+
+class IpcDispatchError extends createTaggedError({
+  name: 'IpcDispatchError',
+  message: 'IPC dispatch failed for request $requestId: $reason',
+}) {}
+
+// ── Button parsing ───────────────────────────────────────────────────────
+
+const VALID_COLORS = new Set<ActionButtonColor>([
+  'white',
+  'blue',
+  'green',
+  'red',
+])
+
+type ParsedButton = { label: string; color?: ActionButtonColor }
+
+function parseButtons(raw: unknown): ParsedButton[] {
+  if (!Array.isArray(raw)) return []
+  const results: ParsedButton[] = []
+  for (const value of raw) {
+    if (!value || typeof value !== 'object') continue
+    const label = (typeof value.label === 'string' ? value.label : '')
+      .trim()
+      .slice(0, 80)
+    if (!label) continue
+    const color =
+      typeof value.color === 'string' &&
+      VALID_COLORS.has(value.color as ActionButtonColor)
+        ? (value.color as ActionButtonColor)
+        : undefined
+    results.push({ label, color })
+    if (results.length >= 3) break
+  }
+  return results
+}
+
+// ── Request dispatch ─────────────────────────────────────────────────────
+
+type ClaimedRequest = {
+  id: string
+  type: string
+  session_id: string
+  thread_id: string
+  payload: string
+}
+
+async function dispatchRequest({
+  req,
+  discordClient,
+}: {
+  req: ClaimedRequest
+  discordClient: Client
+}) {
+  switch (req.type) {
+    case 'file_upload': {
+      const parsed = errore.try({
+        try: () =>
+          JSON.parse(req.payload) as {
+            prompt?: string
+            maxFiles?: number
+            directory?: string
+          },
+        catch: (e) =>
+          new IpcDispatchError({
+            requestId: req.id,
+            reason: 'Invalid payload JSON',
+            cause: e,
+          }),
+      })
+      if (parsed instanceof Error) {
+        await completeIpcRequest({
+          id: req.id,
+          response: JSON.stringify({ error: parsed.message }),
+        })
+        return parsed
+      }
+
+      const thread = await discordClient.channels
+        .fetch(req.thread_id)
+        .catch(
+          (e) =>
+            new IpcDispatchError({
+              requestId: req.id,
+              reason: 'Thread fetch failed',
+              cause: e,
+            }),
+        )
+      if (thread instanceof Error) {
+        await completeIpcRequest({
+          id: req.id,
+          response: JSON.stringify({ error: 'Thread not found' }),
+        })
+        return thread
+      }
+      if (!thread?.isThread()) {
+        await completeIpcRequest({
+          id: req.id,
+          response: JSON.stringify({ error: 'Thread not found' }),
+        })
+        return new IpcDispatchError({
+          requestId: req.id,
+          reason: 'Channel is not a thread',
+        })
+      }
+
+      // Fire-and-forget: showFileUploadButton waits for user interaction
+      // (button click + modal + file download) which can take minutes.
+      // Don't block the dispatch loop — complete the IPC request asynchronously.
+      showFileUploadButton({
+        thread,
+        sessionId: req.session_id,
+        directory: parsed.directory || '',
+        prompt: parsed.prompt || 'Please upload files',
+        maxFiles: Math.min(10, Math.max(1, parsed.maxFiles || 5)),
+      })
+        .then((filePaths) => {
+          return completeIpcRequest({
+            id: req.id,
+            response: JSON.stringify({ filePaths }),
+          })
+        })
+        .catch((e) => {
+          ipcLogger.error(
+            '[IPC] File upload error:',
+            e instanceof Error ? e.message : String(e),
+          )
+          return completeIpcRequest({
+            id: req.id,
+            response: JSON.stringify({
+              error: e instanceof Error ? e.message : 'File upload failed',
+            }),
+          })
+        })
+        .catch((e) => {
+          void notifyError(e, 'IPC file upload completion update failed')
+        })
+      return
+    }
+
+    case 'action_buttons': {
+      const parsed = errore.try({
+        try: () =>
+          JSON.parse(req.payload) as { buttons?: unknown; directory?: string },
+        catch: (e) =>
+          new IpcDispatchError({
+            requestId: req.id,
+            reason: 'Invalid payload JSON',
+            cause: e,
+          }),
+      })
+      if (parsed instanceof Error) {
+        await completeIpcRequest({
+          id: req.id,
+          response: JSON.stringify({ error: parsed.message }),
+        })
+        return parsed
+      }
+
+      const buttons = parseButtons(parsed.buttons)
+      if (buttons.length === 0) {
+        await completeIpcRequest({
+          id: req.id,
+          response: JSON.stringify({ error: 'No valid buttons' }),
+        })
+        return
+      }
+
+      const thread = await discordClient.channels
+        .fetch(req.thread_id)
+        .catch(
+          (e) =>
+            new IpcDispatchError({
+              requestId: req.id,
+              reason: 'Thread fetch failed',
+              cause: e,
+            }),
+        )
+      if (thread instanceof Error) {
+        await completeIpcRequest({
+          id: req.id,
+          response: JSON.stringify({ error: 'Thread not found' }),
+        })
+        return thread
+      }
+      if (!thread?.isThread()) {
+        await completeIpcRequest({
+          id: req.id,
+          response: JSON.stringify({ error: 'Thread not found' }),
+        })
+        return new IpcDispatchError({
+          requestId: req.id,
+          reason: 'Channel is not a thread',
+        })
+      }
+
+      queueActionButtonsRequest({
+        sessionId: req.session_id,
+        threadId: req.thread_id,
+        directory: parsed.directory || '',
+        buttons,
+      })
+
+      await completeIpcRequest({
+        id: req.id,
+        response: JSON.stringify({ ok: true }),
+      })
+      return
+    }
+
+    default: {
+      await completeIpcRequest({
+        id: req.id,
+        response: JSON.stringify({ error: `Unknown IPC type: ${req.type}` }),
+      })
+      return
+    }
+  }
+}
+
+// ── Polling lifecycle ────────────────────────────────────────────────────
+
+let pollingInterval: ReturnType<typeof setInterval> | null = null
+
+// Cancel requests stuck in 'processing' longer than 24 hours. Users often
+// come back the next day to click permission/question/file-upload buttons,
+// so we keep IPC rows alive for a full day. Checked every 30 seconds.
+const STALE_TTL_MS = 24 * 60 * 60 * 1000
+const STALE_CHECK_INTERVAL_MS = 30 * 1000
+let lastStaleCheck = 0
+
+/**
+ * Start polling the ipc_requests table for pending requests from the plugin.
+ * Claims rows atomically (pending -> processing) to prevent duplicate dispatch.
+ * Uses an in-flight guard to prevent overlapping poll ticks.
+ */
+export async function startIpcPolling({
+  discordClient,
+}: {
+  discordClient: Client
+}) {
+  // Clean up stale requests from previous runs before first poll tick
+  await cancelAllPendingIpcRequests().catch((e) => {
+    ipcLogger.warn('Failed to cancel stale IPC requests:', (e as Error).message)
+    void notifyError(e, 'Failed to cancel stale IPC requests')
+  })
+
+  let polling = false
+  pollingInterval = setInterval(async () => {
+    if (polling) return
+    polling = true
+
+    // Periodically sweep requests stuck in 'processing' past the TTL
+    const now = Date.now()
+    if (now - lastStaleCheck > STALE_CHECK_INTERVAL_MS) {
+      lastStaleCheck = now
+      await cancelStaleProcessingRequests({ ttlMs: STALE_TTL_MS }).catch(
+        (e) => {
+          ipcLogger.warn('Stale sweep failed:', (e as Error).message)
+          void notifyError(e, 'IPC stale sweep failed')
+        },
+      )
+    }
+
+    const claimed = await claimPendingIpcRequests().catch(
+      (e) =>
+        new IpcDispatchError({
+          requestId: 'poll',
+          reason: 'Claim failed',
+          cause: e,
+        }),
+    )
+    if (claimed instanceof Error) {
+      ipcLogger.error('IPC claim failed:', claimed.message)
+      void notifyError(claimed, 'IPC claim failed')
+      polling = false
+      return
+    }
+
+    for (const req of claimed) {
+      const result = await dispatchRequest({ req, discordClient }).catch(
+        (e) =>
+          new IpcDispatchError({
+            requestId: req.id,
+            reason: 'Dispatch threw',
+            cause: e,
+          }),
+      )
+      if (result instanceof Error) {
+        ipcLogger.error(`IPC dispatch error for ${req.type}:`, result.message)
+        void notifyError(result, `IPC dispatch error for ${req.type}`)
+      }
+    }
+
+    polling = false
+  }, 200)
+}
+
+export function stopIpcPolling() {
+  if (!pollingInterval) return
+  clearInterval(pollingInterval)
+  pollingInterval = null
+}

package/src/ipc-tools-plugin.ts

@@ -0,0 +1,236 @@
+// OpenCode plugin that provides IPC-based tools for Discord interaction:
+// - kimaki_file_upload: prompts the Discord user to upload files via native picker
+// - kimaki_action_buttons: shows clickable action buttons in the Discord thread
+//
+// Tools communicate with the bot process via IPC rows in SQLite (the plugin
+// runs inside the OpenCode server process, not the bot process).
+//
+// Exported from kimaki-opencode-plugin.ts — each export is treated as a separate
+// plugin by OpenCode's plugin loader.
+
+import type { Plugin } from '@opencode-ai/plugin'
+import type { ToolContext } from '@opencode-ai/plugin/tool'
+import dedent from 'string-dedent'
+import { z } from 'zod'
+import { setDataDir } from './config.js'
+import { createPluginLogger, setPluginLogFilePath } from './plugin-logger.js'
+import { initSentry } from './sentry.js'
+
+// Inlined from '@opencode-ai/plugin/tool' because the subpath value import
+// fails at runtime in global npm installs (#35). Opencode loads this plugin
+// file in its own process and resolves modules from kimaki's install dir,
+// but the '/tool' subpath export isn't found by opencode's module resolver.
+// The type-only imports above are fine (erased at compile time).
+//
+// NOTE: @opencode-ai/plugin bundles its own zod 4.1.x as a hard dependency
+// while goke (used by cli.ts) requires zod 4.3.x. This version skew makes
+// the Plugin return type structurally incompatible with our local tool()
+// even though runtime behavior is identical. ipcToolsPlugin is cast to
+// Plugin via unknown to bypass this purely type-level incompatibility.
+function tool<Args extends z.ZodRawShape>(input: {
+  description: string
+  args: Args
+  execute(
+    args: z.infer<z.ZodObject<Args>>,
+    context: ToolContext,
+  ): Promise<string>
+}) {
+  return input
+}
+
+const logger = createPluginLogger('OPENCODE')
+
+const FILE_UPLOAD_TIMEOUT_MS = 6 * 60 * 1000
+const DEFAULT_FILE_UPLOAD_MAX_FILES = 5
+const ACTION_BUTTON_TIMEOUT_MS = 30 * 1000
+
+async function loadDatabaseModule() {
+  // The plugin-loading e2e test boots OpenCode directly without the bot-side
+  // Hrana env vars. Lazy-loading avoids pulling Prisma + libsql sqlite mode
+  // during plugin startup when no IPC tool is being executed yet.
+  return import('./database.js')
+}
+
+// @opencode-ai/plugin bundles zod 4.1.x as a hard dep; our code uses 4.3.x
+// (required by goke for ~standard.jsonSchema). The Plugin return type is
+// structurally incompatible due to _zod.version.minor skew even though
+// runtime behavior is identical. `any` bypasses the type-level mismatch —
+// opencode's plugin loader doesn't care about the zod version at runtime.
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const ipcToolsPlugin: any = async () => {
+  initSentry()
+
+    const dataDir = process.env.KIMAKI_DATA_DIR
+    if (dataDir) {
+      setDataDir(dataDir)
+      setPluginLogFilePath(dataDir)
+    }
+
+  return {
+    tool: {
+      kimaki_file_upload: tool({
+        description:
+          'Prompt the Discord user to upload files using a native file picker modal. ' +
+          'The user sees a button, clicks it, and gets a file upload dialog. ' +
+          'Returns the local file paths of downloaded files in the project directory. ' +
+          'Use this when you need the user to provide files (images, documents, configs, etc.). ' +
+          'IMPORTANT: Always call this tool last in your message, after all text parts.',
+        args: {
+          prompt: z
+            .string()
+            .describe(
+              'Message shown to the user explaining what files to upload',
+            ),
+          maxFiles: z
+            .number()
+            .min(1)
+            .max(10)
+            .optional()
+            .describe(
+              'Maximum number of files the user can upload (1-10, default 5)',
+            ),
+        },
+        async execute({ prompt, maxFiles }, context) {
+          const { getPrisma, createIpcRequest, getIpcRequestById } = await loadDatabaseModule()
+          const prisma = await getPrisma()
+          const row = await prisma.thread_sessions.findFirst({
+            where: { session_id: context.sessionID },
+            select: { thread_id: true },
+          })
+
+          if (!row?.thread_id) {
+            return 'Could not find thread for current session'
+          }
+
+          const ipcRow = await createIpcRequest({
+            type: 'file_upload',
+            sessionId: context.sessionID,
+            threadId: row.thread_id,
+            payload: JSON.stringify({
+              prompt,
+              maxFiles: maxFiles || DEFAULT_FILE_UPLOAD_MAX_FILES,
+              directory: context.directory,
+            }),
+          })
+
+          const deadline = Date.now() + FILE_UPLOAD_TIMEOUT_MS
+          const POLL_INTERVAL_MS = 300
+          while (Date.now() < deadline) {
+            await new Promise((resolve) => {
+              setTimeout(resolve, POLL_INTERVAL_MS)
+            })
+            const updated = await getIpcRequestById({ id: ipcRow.id })
+            if (!updated || updated.status === 'cancelled') {
+              return 'File upload was cancelled'
+            }
+            if (updated.response) {
+              const parsed = JSON.parse(updated.response) as {
+                filePaths?: string[]
+                error?: string
+              }
+              if (parsed.error) {
+                return `File upload failed: ${parsed.error}`
+              }
+              const filePaths = parsed.filePaths || []
+              if (filePaths.length === 0) {
+                return 'No files were uploaded (user may have cancelled or sent a new message)'
+              }
+              return `Files uploaded successfully:\n${filePaths.join('\n')}`
+            }
+          }
+
+          return 'File upload timed out - user did not upload files within the time limit'
+        },
+      }),
+      kimaki_action_buttons: tool({
+        description: dedent`
+          Show action buttons in the current Discord thread for quick confirmations.
+          Use this when the user can respond by clicking one of up to 3 buttons.
+          Prefer a single button whenever possible.
+          Default color is white (same visual style as permission deny button).
+          If you need more than 3 options, use the question tool instead.
+          IMPORTANT: Always call this tool last in your message, after all text parts.
+
+          Examples:
+          - buttons: [{"label":"Yes, proceed"}]
+          - buttons: [{"label":"Approve","color":"green"}]
+          - buttons: [
+              {"label":"Confirm","color":"blue"},
+              {"label":"Cancel","color":"white"}
+            ]
+        `,
+        args: {
+          buttons: z
+            .array(
+              z.object({
+                label: z
+                  .string()
+                  .min(1)
+                  .max(80)
+                  .describe('Button label shown to the user (1-80 chars)'),
+                color: z
+                  .enum(['white', 'blue', 'green', 'red'])
+                  .optional()
+                  .describe(
+                    'Optional button color. white is default and preferred for most confirmations.',
+                  ),
+              }),
+            )
+            .min(1)
+            .max(3)
+            .describe(
+              'Array of 1-3 action buttons. Prefer one button whenever possible.',
+            ),
+        },
+        async execute({ buttons }, context) {
+          const { getPrisma, createIpcRequest, getIpcRequestById } = await loadDatabaseModule()
+          const prisma = await getPrisma()
+          const row = await prisma.thread_sessions.findFirst({
+            where: { session_id: context.sessionID },
+            select: { thread_id: true },
+          })
+
+          if (!row?.thread_id) {
+            return 'Could not find thread for current session'
+          }
+
+          const ipcRow = await createIpcRequest({
+            type: 'action_buttons',
+            sessionId: context.sessionID,
+            threadId: row.thread_id,
+            payload: JSON.stringify({
+              buttons,
+              directory: context.directory,
+            }),
+          })
+
+          const deadline = Date.now() + ACTION_BUTTON_TIMEOUT_MS
+          const POLL_INTERVAL_MS = 200
+          while (Date.now() < deadline) {
+            await new Promise((resolve) => {
+              setTimeout(resolve, POLL_INTERVAL_MS)
+            })
+            const updated = await getIpcRequestById({ id: ipcRow.id })
+            if (!updated || updated.status === 'cancelled') {
+              return 'Action button request was cancelled'
+            }
+            if (updated.response) {
+              const parsed = JSON.parse(updated.response) as {
+                ok?: boolean
+                error?: string
+              }
+              if (parsed.error) {
+                return `Action button request failed: ${parsed.error}`
+              }
+              return `Action button(s) shown: ${buttons.map((button) => button.label).join(', ')}`
+            }
+          }
+
+          return 'Action button request timed out'
+        },
+      }),
+    },
+  }
+}
+
+export { ipcToolsPlugin }