@otto-assistant/bridge 0.4.92

package/src/session-handler/model-utils.ts

@@ -0,0 +1,183 @@
+// Model resolution utilities.
+// getDefaultModel resolves the default model from OpenCode when no user preference is set.
+
+import fs from 'node:fs'
+import path from 'node:path'
+import { xdgState } from 'xdg-basedir'
+import * as errore from 'errore'
+import { type initializeOpencodeForDirectory } from '../opencode.js'
+import { createLogger, LogPrefix } from '../logger.js'
+import type { ScheduledTaskScheduleKind } from '../database.js'
+
+const sessionLogger = createLogger(LogPrefix.SESSION)
+
+export type DefaultModelSource =
+  | 'opencode-config'
+  | 'opencode-recent'
+  | 'opencode-provider-default'
+
+export type SessionStartSourceContext = {
+  scheduleKind: ScheduledTaskScheduleKind
+  scheduledTaskId?: number
+}
+
+/**
+ * Read user's recent models from OpenCode TUI's state file.
+ * Uses same path as OpenCode: path.join(xdgState, "opencode", "model.json")
+ * Returns all recent models so we can iterate until finding a valid one.
+ * See: opensrc/repos/github.com/sst/opencode/packages/opencode/src/global/index.ts
+ */
+function getRecentModelsFromTuiState(): Array<{
+  providerID: string
+  modelID: string
+}> {
+  if (!xdgState) {
+    return []
+  }
+  // Same path as OpenCode TUI: path.join(Global.Path.state, "model.json")
+  const modelJsonPath = path.join(xdgState, 'opencode', 'model.json')
+
+  const result = errore.tryFn(() => {
+    const content = fs.readFileSync(modelJsonPath, 'utf-8')
+    const data = JSON.parse(content) as {
+      recent?: Array<{ providerID: string; modelID: string }>
+    }
+    return data.recent ?? []
+  })
+
+  if (result instanceof Error) {
+    // File doesn't exist or is invalid - this is normal for fresh installs
+    return []
+  }
+
+  return result
+}
+
+/**
+ * Parse a model string in format "provider/model" into providerID and modelID.
+ */
+function parseModelString(
+  model: string,
+): { providerID: string; modelID: string } | undefined {
+  const [providerID, ...modelParts] = model.split('/')
+  const modelID = modelParts.join('/')
+  if (!providerID || !modelID) {
+    return undefined
+  }
+  return { providerID, modelID }
+}
+
+/**
+ * Validate that a model is available (provider connected + model exists).
+ */
+function isModelValid(
+  model: { providerID: string; modelID: string },
+  connected: string[],
+  providers: Array<{ id: string; models?: Record<string, unknown> }>,
+): boolean {
+  const isConnected = connected.includes(model.providerID)
+  const provider = providers.find((p) => {
+    return p.id === model.providerID
+  })
+  const modelExists = provider?.models && model.modelID in provider.models
+  return isConnected && !!modelExists
+}
+
+/**
+ * Get the default model from OpenCode when no user preference is set.
+ * Priority (matches OpenCode TUI behavior):
+ * 1. OpenCode config.model setting
+ * 2. User's recent models from TUI state (~/.local/state/opencode/model.json)
+ * 3. First connected provider's default model from API
+ * Returns the model and its source.
+ */
+export async function getDefaultModel({
+  getClient,
+}: {
+  getClient: Awaited<ReturnType<typeof initializeOpencodeForDirectory>>
+}): Promise<
+  | { providerID: string; modelID: string; source: DefaultModelSource }
+  | undefined
+> {
+  if (getClient instanceof Error) {
+    return undefined
+  }
+
+  // Fetch connected providers to validate any model we return
+  const providersResponse = await errore.tryAsync(() => {
+    return getClient().provider.list({})
+  })
+  if (providersResponse instanceof Error) {
+    sessionLogger.log(
+      `[MODEL] Failed to fetch providers for default model:`,
+      providersResponse.message,
+    )
+    return undefined
+  }
+  if (!providersResponse.data) {
+    return undefined
+  }
+
+  const {
+    connected,
+    default: defaults,
+    all: providers,
+  } = providersResponse.data
+  if (connected.length === 0) {
+    sessionLogger.log(`[MODEL] No connected providers found`)
+    return undefined
+  }
+
+  // 1. Check OpenCode config.model setting (highest priority after user preference)
+  const configResponse = await errore.tryAsync(() => {
+    return getClient().config.get({})
+  })
+  if (!(configResponse instanceof Error) && configResponse.data?.model) {
+    const configModel = parseModelString(configResponse.data.model)
+    if (configModel && isModelValid(configModel, connected, providers)) {
+      sessionLogger.log(
+        `[MODEL] Using config model: ${configModel.providerID}/${configModel.modelID}`,
+      )
+      return { ...configModel, source: 'opencode-config' }
+    }
+    if (configModel) {
+      sessionLogger.log(
+        `[MODEL] Config model ${configResponse.data.model} not available, checking recent`,
+      )
+    }
+  }
+
+  // 2. Try to use user's recent models from TUI state (iterate until finding valid one)
+  const recentModels = getRecentModelsFromTuiState()
+  for (const recentModel of recentModels) {
+    if (isModelValid(recentModel, connected, providers)) {
+      sessionLogger.log(
+        `[MODEL] Using recent TUI model: ${recentModel.providerID}/${recentModel.modelID}`,
+      )
+      return { ...recentModel, source: 'opencode-recent' }
+    }
+  }
+  if (recentModels.length > 0) {
+    sessionLogger.log(`[MODEL] No valid recent TUI models found`)
+  }
+
+  // 3. Fall back to first connected provider's default model
+  const firstConnected = connected[0]
+  if (!firstConnected) {
+    return undefined
+  }
+  const defaultModelId = defaults[firstConnected]
+  if (!defaultModelId) {
+    sessionLogger.log(`[MODEL] No default model for provider ${firstConnected}`)
+    return undefined
+  }
+
+  sessionLogger.log(
+    `[MODEL] Using provider default: ${firstConnected}/${defaultModelId}`,
+  )
+  return {
+    providerID: firstConnected,
+    modelID: defaultModelId,
+    source: 'opencode-provider-default',
+  }
+}

package/src/session-handler/opencode-session-event-log.ts

@@ -0,0 +1,130 @@
+// Debug helper for writing raw OpenCode event stream entries as JSONL.
+// When enabled, writes one file per session ID so event ordering and
+// lifecycle behavior can be analyzed with jq.
+
+import fs from 'node:fs'
+import path from 'node:path'
+import type { Event as OpenCodeEvent } from '@opencode-ai/sdk/v2'
+import * as errore from 'errore'
+import { getDataDir } from '../config.js'
+
+let eventLogDirPromise: Promise<string> | null = null
+let eventLogWriteDisabled = false
+
+export function isOpencodeSessionEventLogEnabled(): boolean {
+  return process.env['KIMAKI_LOG_OPENCODE_SESSION_EVENTS'] === '1'
+}
+
+export function getOpencodeEventSessionId(event: OpenCodeEvent): string | undefined {
+  switch (event.type) {
+    case 'message.updated':
+      return event.properties.info.sessionID
+    case 'message.part.updated':
+      return event.properties.part.sessionID
+    case 'message.part.delta':
+    case 'message.part.removed':
+    case 'session.status':
+    case 'session.idle':
+    case 'session.diff':
+    case 'permission.asked':
+    case 'permission.replied':
+    case 'question.asked':
+    case 'question.replied':
+    case 'question.rejected':
+      return event.properties.sessionID
+    case 'session.error':
+      return event.properties.sessionID
+    case 'session.created':
+    case 'session.updated':
+    case 'session.deleted':
+      return event.properties.info.id
+    default:
+      return undefined
+  }
+}
+
+function sanitizeSessionIdForFilename(sessionId: string): string {
+  return sessionId.replace(/[^a-zA-Z0-9._-]/g, '_')
+}
+
+async function resolveEventLogDirectory(): Promise<string> {
+  if (!eventLogDirPromise) {
+    eventLogDirPromise = (async () => {
+      const configuredEventLogDir = process.env['KIMAKI_OPENCODE_SESSION_EVENTS_DIR']
+      const baseDir = configuredEventLogDir || path.join(getDataDir(), 'opencode-session-events')
+      await fs.promises.mkdir(baseDir, { recursive: true })
+      return baseDir
+    })()
+  }
+  return eventLogDirPromise
+}
+
+export type OpencodeEventLogEntry = {
+  timestamp: number
+  threadId: string
+  projectDirectory: string
+  event: OpenCodeEvent
+}
+
+export function buildOpencodeEventLogLine({
+  timestamp,
+  threadId,
+  projectDirectory,
+  event,
+}: {
+  timestamp: number
+  threadId: string
+  projectDirectory: string
+  event: OpenCodeEvent
+}): OpencodeEventLogEntry {
+  return {
+    timestamp,
+    threadId,
+    projectDirectory,
+    event,
+  }
+}
+
+export async function appendOpencodeSessionEventLog(
+  entry: Omit<OpencodeEventLogEntry, 'timestamp'>,
+): Promise<Error | null> {
+  if (!isOpencodeSessionEventLogEnabled() || eventLogWriteDisabled) {
+    return null
+  }
+
+  const sessionId = getOpencodeEventSessionId(entry.event)
+  if (!sessionId) {
+    return null
+  }
+
+  const logDirResult = await errore.tryAsync(() => {
+    return resolveEventLogDirectory()
+  })
+  if (logDirResult instanceof Error) {
+    eventLogWriteDisabled = true
+    return logDirResult
+  }
+
+  const safeSessionId = sanitizeSessionIdForFilename(sessionId)
+  const logFilePath = path.join(logDirResult, `${safeSessionId}.jsonl`)
+
+  const now = Date.now()
+  const line = `${JSON.stringify(
+    buildOpencodeEventLogLine({
+      timestamp: now,
+      threadId: entry.threadId,
+      projectDirectory: entry.projectDirectory,
+      event: entry.event,
+    }),
+  )}\n`
+
+  const appendResult = await errore.tryAsync(() => {
+    return fs.promises.appendFile(logFilePath, line, 'utf8')
+  })
+  if (appendResult instanceof Error) {
+    eventLogWriteDisabled = true
+    return appendResult
+  }
+
+  return null
+}

package/src/session-handler/thread-runtime-state.ts

@@ -0,0 +1,212 @@
+// Per-thread state type, transition functions, and selectors.
+// All transitions operate on the global store from ../store.js.
+//
+// ThreadRunState is a value-type: one entry per active thread in the
+// global store's `threads` Map. Transition functions produce new Map +
+// new ThreadRunState objects each time (immutable updates).
+//
+// Derived helpers (queue checks) compute from state and are never
+// stored — they are always re-derived from ThreadRunState.
+//
+// STATE DISCIPLINE: keep as little state as possible. Before adding any new
+// state field, ask if it can be derived from existing state instead.
+
+import type { DiscordFileAttachment } from '../message-formatting.js'
+import type { RepliedMessageContext } from '../system-message.js'
+import { store } from '../store.js'
+
+// ── Shared types ─────────────────────────────────────────────────
+
+export type QueuedMessage = {
+  // The text content to send to the OpenCode session (user message or
+  // transcribed voice message). Always present.
+  prompt: string
+  // Discord user ID of the message author. Used for permission checks
+  // and attribution in the session start source tracking.
+  userId: string
+  // Discord display name. Used in runtime drain logging.
+  username: string
+  // Image/file attachments extracted from the Discord message. Sent as
+  // file parts alongside the prompt in the SDK call.
+  images?: DiscordFileAttachment[]
+  // Bot application ID. Used for model-preference resolution fallback
+  // (looking up channel/session model overrides keyed by appId).
+  appId?: string
+  // When set, dispatches via session.command() instead of session.prompt().
+  // Used by /queue-command and user-defined slash commands.
+  command?: { name: string; arguments: string }
+  // First-dispatch-only overrides — used when creating a new session.
+  // Subsequent queue drains ignore these since the session already exists.
+  // Set by --agent/--model/--permission flags on kimaki send or slash commands.
+  agent?: string
+  model?: string
+  // Raw permission rule strings ("tool:action" or "tool:pattern:action").
+  // Parsed and merged into session permissions on creation.
+  permissions?: string[]
+  // Injection guard scan patterns (e.g. "bash:*", "webfetch:*").
+  // Written to a temp config file after session creation so the plugin
+  // can check per-session whether to scan tool outputs.
+  injectionGuardPatterns?: string[]
+  // Discord message ID and thread ID of the source message. Embedded in
+  // <discord-user> synthetic context so the external sync loop can detect
+  // messages that originated from Discord and skip re-mirroring them.
+  sourceMessageId?: string
+  sourceThreadId?: string
+  repliedMessage?: RepliedMessageContext
+  // Tracking fields for scheduled tasks. Stored in the DB via
+  // setSessionStartSource() after the session is created, so the session
+  // list can show which sessions were started by scheduled tasks.
+  sessionStartScheduleKind?: 'at' | 'cron'
+  sessionStartScheduledTaskId?: number
+}
+
+// ── Per-thread state (value inside the Map) ──────────────────────
+
+export type ThreadRunState = {
+  // OpenCode session ID for this thread. Set lazily by ensureSession()
+  // on first dispatch (not on thread creation). Persists across multiple
+  // prompt runs — the same session is reused for the thread's lifetime.
+  // Also stored in the DB (thread_sessions table) for recovery after restart.
+  // Changes: set on first dispatch, may be re-set if the old session is
+  // invalid and a new one is created. Never cleared except on dispose.
+  // Read by: dispatchPrompt, ensureSession, abortSessionViaApi, footer.
+  sessionId: string | undefined
+
+  // Stable first author for this thread runtime. Used for session-stable
+  // system prompt examples like `kimaki send --user ...` so notifications keep
+  // working without changing the cached system prompt on every follow-up.
+  sessionUsername: string | undefined
+
+  // FIFO queue of pending inputs waiting for kimaki-local dispatch.
+  // Normal user messages default to opencode queue mode; this queue is
+  // for explicit local-queue flows (for example /queue).
+  // Changes: enqueueItem (append), dequeueItem (head removal), clearQueueItems.
+  // Read by: runtime queue gating, hasQueue helpers, /queue command display.
+  queueItems: QueuedMessage[]
+
+  // Listener lifetime controller — scoped to the entire runtime lifetime,
+  // NOT per-prompt. Only aborted on dispose() or fatal error. Run abort
+  // never kills the listener — the SSE event loop stays alive across runs
+  // so subsequent prompts reuse the same listener.
+  // Changes: created in constructor, aborted only on dispose.
+  listenerController: AbortController | undefined
+
+  // Output dedup: tracks which part IDs have already been sent to Discord.
+  // Prevents resending the same tool output or text part on SSE reconnect.
+  // Lives at thread level because it accumulates
+  // across runs for the runtime's lifetime — never reset per-run.
+  // Changes: bootstrapped from DB on session resume, added on each part
+  // sent to Discord, removed on send failure, also updated in subtask flows.
+  // Read by: handleMainPart() dedup check, subtask routing.
+  sentPartIds: Set<string>
+}
+
+// ── Initial state factory ────────────────────────────────────────
+
+export function initialThreadState(): ThreadRunState {
+  return {
+    sessionId: undefined,
+    sessionUsername: undefined,
+    queueItems: [],
+    listenerController: undefined,
+    sentPartIds: new Set(),
+  }
+}
+
+// ── Derived helpers (compute, never store) ───────────────────────
+
+export function hasQueue(t: ThreadRunState): boolean {
+  return t.queueItems.length > 0
+}
+
+// ── Pure transition helpers ──────────────────────────────────────
+// Immutable: produces new Map + new ThreadRunState object each time.
+
+export function updateThread(
+  threadId: string,
+  updater: (t: ThreadRunState) => ThreadRunState,
+): void {
+  store.setState((s) => {
+    const existing = s.threads.get(threadId)
+    if (!existing) {
+      return s
+    }
+    const newThreads = new Map(s.threads)
+    newThreads.set(threadId, updater(existing))
+    return { threads: newThreads }
+  })
+}
+
+export function ensureThread(threadId: string): void {
+  if (store.getState().threads.has(threadId)) {
+    return
+  }
+  store.setState((s) => {
+    const newThreads = new Map(s.threads)
+    newThreads.set(threadId, initialThreadState())
+    return { threads: newThreads }
+  })
+}
+
+export function removeThread(threadId: string): void {
+  store.setState((s) => {
+    if (!s.threads.has(threadId)) {
+      return s
+    }
+    const newThreads = new Map(s.threads)
+    newThreads.delete(threadId)
+    return { threads: newThreads }
+  })
+}
+
+export function setSessionId(threadId: string, sessionId: string): void {
+  updateThread(threadId, (t) => ({ ...t, sessionId }))
+}
+
+export function setSessionUsername(threadId: string, username: string): void {
+  updateThread(threadId, (t) => {
+    if (t.sessionUsername) {
+      return t
+    }
+    return { ...t, sessionUsername: username }
+  })
+}
+
+export function enqueueItem(threadId: string, item: QueuedMessage): void {
+  updateThread(threadId, (t) => ({
+    ...t,
+    queueItems: [...t.queueItems, item],
+  }))
+}
+
+// Atomic dequeue: read + write in one setState call to prevent
+// a concurrent enqueue between read and write from losing items.
+export function dequeueItem(threadId: string): QueuedMessage | undefined {
+  let next: QueuedMessage | undefined
+  store.setState((s) => {
+    const t = s.threads.get(threadId)
+    if (!t || t.queueItems.length === 0) {
+      return s
+    }
+    const [head, ...rest] = t.queueItems
+    next = head
+    const newThreads = new Map(s.threads)
+    newThreads.set(threadId, { ...t, queueItems: rest })
+    return { threads: newThreads }
+  })
+  return next
+}
+
+export function clearQueueItems(threadId: string): void {
+  updateThread(threadId, (t) => ({ ...t, queueItems: [] }))
+}
+
+// ── Queries ──────────────────────────────────────────────────────
+
+export function getThreadState(threadId: string): ThreadRunState | undefined {
+  return store.getState().threads.get(threadId)
+}
+
+export function getThreadIds(): string[] {
+  return [...store.getState().threads.keys()]
+}