@otto-assistant/otto 0.1.2 → 0.7.15

package/src/wait-session.ts

@@ -0,0 +1,273 @@
+// Wait utilities for polling session completion.
+// Used by `otto send --wait` to block until a session finishes,
+// then output the session markdown to stdout.
+
+import { getThreadSession } from './database.js'
+import { initializeOpencodeForDirectory } from './opencode.js'
+import { ShareMarkdown } from './markdown.js'
+import { createLogger, LogPrefix } from './logger.js'
+
+const waitLogger = createLogger(LogPrefix.SESSION)
+const REPORT_POLL_INTERVAL_MS = 2_000
+const DEFAULT_COMPLETION_TIMEOUT_MS = 30 * 60 * 1000
+
+type SessionMessagePart = {
+  type: string
+  text?: string
+  synthetic?: boolean
+}
+
+type SessionMessage = {
+  info: {
+    id: string
+    role: string
+    time?: {
+      completed?: number
+    }
+  }
+  parts: SessionMessagePart[]
+}
+
+/**
+ * Poll the otto database until a session ID appears for the given thread.
+ * The bot writes this mapping in session-handler.ts:551 when it picks up
+ * the thread and creates/reuses a session.
+ */
+export async function waitForSessionId({
+  threadId,
+  timeoutMs = 120_000,
+}: {
+  threadId: string
+  timeoutMs?: number
+}): Promise<string> {
+  const startTime = Date.now()
+  const pollIntervalMs = 2_000
+
+  while (Date.now() - startTime < timeoutMs) {
+    const sessionId = await getThreadSession(threadId)
+    if (sessionId) {
+      waitLogger.log(`Session ID resolved: ${sessionId}`)
+      return sessionId
+    }
+    await new Promise((resolve) => {
+      setTimeout(resolve, pollIntervalMs)
+    })
+  }
+
+  throw new Error(
+    `Timed out waiting for session ID (thread: ${threadId}, timeout: ${timeoutMs}ms)`,
+  )
+}
+
+/**
+ * Poll the OpenCode SDK until the session's last assistant message
+ * has `time.completed` set, meaning the model finished responding.
+ */
+export async function waitForSessionComplete({
+  projectDirectory,
+  sessionId,
+  timeoutMs = DEFAULT_COMPLETION_TIMEOUT_MS,
+}: {
+  projectDirectory: string
+  sessionId: string
+  timeoutMs?: number
+}): Promise<void> {
+  const pollIntervalMs = 3_000
+  const startTime = Date.now()
+
+  const getClient = await initializeOpencodeForDirectory(projectDirectory)
+  if (getClient instanceof Error) {
+    throw new Error(
+      `Failed to connect to OpenCode server: ${getClient.message}`,
+      {
+        cause: getClient,
+      },
+    )
+  }
+
+  while (Date.now() - startTime < timeoutMs) {
+    const messagesResponse = await getClient().session.messages({
+      sessionID: sessionId,
+    })
+    const messages = messagesResponse.data || []
+
+    // Find the last assistant message
+    const lastAssistant = [...messages]
+      .reverse()
+      .find((m) => m.info.role === 'assistant')
+
+    if (
+      lastAssistant &&
+      lastAssistant.info.role === 'assistant' &&
+      lastAssistant.info.time.completed
+    ) {
+      waitLogger.log(`Session ${sessionId} completed`)
+      return
+    }
+
+    await new Promise((resolve) => {
+      setTimeout(resolve, pollIntervalMs)
+    })
+  }
+
+  throw new Error(
+    `Timed out waiting for session completion (session: ${sessionId}, timeout: ${timeoutMs}ms)`,
+  )
+}
+
+function extractAssistantText(message: SessionMessage): string {
+  const text = message.parts
+    .filter((part) => {
+      return part.type === 'text' && !part.synthetic && Boolean(part.text)
+    })
+    .map((part) => {
+      return part.text?.trim() || ''
+    })
+    .filter((partText) => {
+      return partText.length > 0
+    })
+    .join('\n')
+  return text
+}
+
+export async function waitAndReportSession({
+  threadId,
+  projectDirectory,
+  sessionIdTimeoutMs,
+  completionTimeoutMs = DEFAULT_COMPLETION_TIMEOUT_MS,
+}: {
+  threadId: string
+  projectDirectory: string
+  sessionIdTimeoutMs?: number
+  completionTimeoutMs?: number
+}): Promise<void> {
+  waitLogger.log('Waiting for session ID...')
+  const sessionId = await waitForSessionId({
+    threadId,
+    timeoutMs: sessionIdTimeoutMs,
+  })
+
+  process.stdout.write(
+    [
+      `report: tracking session ${sessionId}`,
+      `report: follow-up -> otto send --session ${sessionId} --prompt "<message>"`,
+      `report: archive -> otto session archive --session ${sessionId}`,
+    ].join('\n') + '\n',
+  )
+
+  const getClient = await initializeOpencodeForDirectory(projectDirectory)
+  if (getClient instanceof Error) {
+    throw new Error(
+      `Failed to connect to OpenCode server: ${getClient.message}`,
+      {
+        cause: getClient,
+      },
+    )
+  }
+
+  const client = getClient()
+  const startedAt = Date.now()
+  const reportedMessageIds: Set<string> = new Set()
+  let lastPrintedAt = 0
+
+  while (Date.now() - startedAt < completionTimeoutMs) {
+    const messagesResponse = await client.session.messages({
+      sessionID: sessionId,
+      directory: projectDirectory,
+    })
+    const messages = (messagesResponse.data || []) as SessionMessage[]
+
+    const completedAssistantMessages = messages.filter((message) => {
+      return (
+        message.info.role === 'assistant' &&
+        Boolean(message.info.time?.completed) &&
+        !reportedMessageIds.has(message.info.id)
+      )
+    })
+
+    for (const message of completedAssistantMessages) {
+      reportedMessageIds.add(message.info.id)
+      const text = extractAssistantText(message)
+      if (!text) {
+        process.stdout.write('report: assistant update (non-text output)\n')
+        continue
+      }
+      process.stdout.write(`report: assistant update\n${text}\n`)
+    }
+
+    const statusResponse = await client.session.status({
+      directory: projectDirectory,
+    })
+    const sessionStatus = statusResponse.data?.[sessionId]
+    const statusType = sessionStatus?.type
+
+    if (statusType === 'idle' || !sessionStatus) {
+      process.stdout.write(`report: session ${sessionId} completed\n`)
+      return
+    }
+
+    const now = Date.now()
+    if (now - lastPrintedAt > 8_000) {
+      process.stdout.write(`report: session ${sessionId} status=${statusType}\n`)
+      lastPrintedAt = now
+    }
+
+    await new Promise((resolve) => {
+      setTimeout(resolve, REPORT_POLL_INTERVAL_MS)
+    })
+  }
+
+  throw new Error(
+    `Timed out waiting for session completion (session: ${sessionId}, timeout: ${completionTimeoutMs}ms)`,
+  )
+}
+
+/**
+ * Wait for session completion and output the session markdown to stdout.
+ * Orchestrates the full wait flow: session ID resolution -> completion -> output.
+ */
+export async function waitAndOutputSession({
+  threadId,
+  projectDirectory,
+  sessionIdTimeoutMs,
+  completionTimeoutMs,
+}: {
+  threadId: string
+  projectDirectory: string
+  sessionIdTimeoutMs?: number
+  completionTimeoutMs?: number
+}): Promise<void> {
+  waitLogger.log('Waiting for session ID...')
+  const sessionId = await waitForSessionId({
+    threadId,
+    timeoutMs: sessionIdTimeoutMs,
+  })
+
+  waitLogger.log(`Waiting for session ${sessionId} to complete...`)
+  await waitForSessionComplete({
+    projectDirectory,
+    sessionId,
+    timeoutMs: completionTimeoutMs,
+  })
+
+  waitLogger.log('Generating session output...')
+  const getClient = await initializeOpencodeForDirectory(projectDirectory)
+  if (getClient instanceof Error) {
+    throw new Error(
+      `Failed to connect to OpenCode server: ${getClient.message}`,
+      {
+        cause: getClient,
+      },
+    )
+  }
+
+  const markdown = new ShareMarkdown(getClient())
+  const result = await markdown.generate({ sessionID: sessionId })
+  if (result instanceof Error) {
+    throw new Error(`Failed to generate session markdown: ${result.message}`, {
+      cause: result,
+    })
+  }
+
+  process.stdout.write(result)
+}

package/src/websockify.ts

@@ -0,0 +1,101 @@
+// In-process WebSocket-to-TCP bridge (websockify replacement).
+// Accepts WebSocket connections and pipes raw bytes to/from a TCP target.
+// Used by /screenshare to bridge noVNC (WebSocket) to a VNC server (TCP).
+// Supports the 'binary' subprotocol required by noVNC.
+
+import { WebSocketServer, WebSocket } from 'ws'
+import net from 'node:net'
+import { createLogger } from './logger.js'
+
+const logger = createLogger('SCREEN')
+
+type WebsockifyOptions = {
+  /** Port for the WebSocket server (0 = auto-assign) */
+  wsPort: number
+  /** TCP target host */
+  tcpHost: string
+  /** TCP target port */
+  tcpPort: number
+}
+
+type WebsockifyInstance = {
+  wss: WebSocketServer
+  /** Resolved port (useful when wsPort=0) */
+  port: number
+  close: () => void
+}
+
+export function startWebsockify({
+  wsPort,
+  tcpHost,
+  tcpPort,
+}: WebsockifyOptions): Promise<WebsockifyInstance> {
+  return new Promise((resolve, reject) => {
+    const wss = new WebSocketServer({
+      port: wsPort,
+      // noVNC negotiates the 'binary' subprotocol
+      handleProtocols: (protocols) => {
+        if (protocols.has('binary')) {
+          return 'binary'
+        }
+        return false
+      },
+    })
+
+    wss.on('listening', () => {
+      const addr = wss.address()
+      const port = typeof addr === 'object' && addr ? addr.port : wsPort
+      logger.log(`Websockify listening on port ${port} → ${tcpHost}:${tcpPort}`)
+      resolve({
+        wss,
+        port,
+        close: () => {
+          for (const client of wss.clients) {
+            client.close()
+          }
+          wss.close()
+        },
+      })
+    })
+
+    wss.on('error', (err) => {
+      reject(new Error('Websockify failed to start', { cause: err }))
+    })
+
+    wss.on('connection', (ws) => {
+      const tcp = net.createConnection(tcpPort, tcpHost, () => {
+        logger.log(`TCP connection established to ${tcpHost}:${tcpPort}`)
+      })
+
+      tcp.on('data', (data) => {
+        if (ws.readyState === WebSocket.OPEN) {
+          ws.send(data)
+        }
+      })
+
+      ws.on('message', (data: Buffer) => {
+        if (!tcp.destroyed) {
+          tcp.write(data)
+        }
+      })
+
+      ws.on('close', () => {
+        tcp.destroy()
+      })
+
+      ws.on('error', (err) => {
+        logger.error('WebSocket error:', err)
+        tcp.destroy()
+      })
+
+      tcp.on('close', () => {
+        ws.close()
+      })
+
+      tcp.on('error', (err) => {
+        logger.error('TCP connection error:', err)
+        ws.close()
+      })
+    })
+  })
+}

package/src/worker-types.ts

@@ -0,0 +1,64 @@
+// Type definitions for worker thread message passing.
+// Defines the protocol between main thread and GenAI worker for
+// audio streaming, tool calls, and session lifecycle management.
+
+// Messages sent from main thread to worker
+export type WorkerInMessage =
+  | {
+      type: 'init'
+      directory: string // Project directory for tools
+      systemMessage?: string
+      guildId: string
+      channelId: string
+      appId: string
+      geminiApiKey?: string | null
+    }
+  | {
+      type: 'sendRealtimeInput'
+      audio?: {
+        mimeType: string
+        data: string // base64
+      }
+      audioStreamEnd?: boolean
+    }
+  | {
+      type: 'sendTextInput'
+      text: string
+    }
+  | {
+      type: 'interrupt'
+    }
+  | {
+      type: 'stop'
+    }
+
+// Messages sent from worker to main thread via parentPort
+export type WorkerOutMessage =
+  | {
+      type: 'assistantOpusPacket'
+      packet: ArrayBuffer // Opus encoded audio packet
+    }
+  | {
+      type: 'assistantStartSpeaking'
+    }
+  | {
+      type: 'assistantStopSpeaking'
+    }
+  | {
+      type: 'assistantInterruptSpeaking'
+    }
+  | {
+      type: 'toolCallCompleted'
+      sessionId: string
+      messageId: string
+      data?: unknown
+      error?: unknown
+      markdown?: string
+    }
+  | {
+      type: 'error'
+      error: string
+    }
+  | {
+      type: 'ready'
+    }