@bprp/flockcode 0.0.2

package/src/opencode.ts

@@ -0,0 +1,278 @@
+// Wrapper around the opencode SDK that maps responses to our types.
+
+import {
+  createOpencodeClient,
+  type Event as OpencodeEvent,
+  type PermissionRequest,
+} from "@opencode-ai/sdk/v2"
+import type {
+  Message,
+  MessagePart,
+} from "./types"
+
+export type { OpencodeEvent }
+
+export type OpencodeClient = ReturnType<typeof createOpencodeClient>
+
+export function createClient(baseUrl: string): OpencodeClient {
+  const client = createOpencodeClient({ baseUrl })
+  return client
+}
+
+/** Map SDK event parts into our app message types. */
+
+export function mapPart(p: any): MessagePart {
+  switch (p.type) {
+    case "text":
+      return { type: "text" as const, id: p.id, text: p.text }
+    case "tool":
+      return {
+        type: "tool" as const,
+        id: p.id,
+        tool: p.tool,
+        state: {
+          status: p.state?.status ?? "pending",
+          input: p.state?.input,
+          output: p.state?.output,
+          title: p.state?.title,
+          error: p.state?.error,
+          metadata: p.state?.metadata,
+          time: p.state?.time,
+        },
+      }
+    case "step-start":
+      return { type: "step-start" as const, id: p.id }
+    case "step-finish":
+      return { type: "step-finish" as const, id: p.id }
+    case "reasoning":
+      return { type: "reasoning" as const, id: p.id, text: p.text }
+    default:
+      return { type: "text" as const, id: p.id, text: `[${p.type}]` }
+  }
+}
+
+export function mapMessage(raw: any): Message {
+  const info = raw.info
+  const parts: MessagePart[] = (raw.parts ?? []).map(mapPart)
+
+  // Extract model info — user messages nest it under info.model,
+  // assistant messages have it flat on info
+  const modelID = info.role === "user"
+    ? info.model?.modelID
+    : info.modelID
+  const providerID = info.role === "user"
+    ? info.model?.providerID
+    : info.providerID
+
+  const agent = info.agent as string | undefined
+
+  const msg: Message = {
+    id: info.id,
+    sessionId: info.sessionID,
+    role: info.role,
+    parts,
+    createdAt: info.time?.created ?? 0,
+    ...(modelID ? { modelID } : {}),
+    ...(providerID ? { providerID } : {}),
+    ...(agent ? { agent } : {}),
+  }
+
+  if (info.role === "assistant") {
+    msg.cost = info.cost
+    msg.tokens = info.tokens
+      ? {
+          input: info.tokens.input,
+          output: info.tokens.output,
+          reasoning: info.tokens.reasoning,
+        }
+      : undefined
+    msg.finish = info.finish
+  }
+
+  return msg
+}
+
+/** Callback signature for receiving Opencode events. */
+export type OpencodeEventCallback = (event: OpencodeEvent) => void
+
+export class Opencode {
+  #client: OpencodeClient
+
+  constructor(baseUrl: string) {
+    this.#client = createOpencodeClient({ baseUrl })
+  }
+
+  async spawnListener(callback: OpencodeEventCallback, baseUrl: string) {
+    const url = `${baseUrl}/global/event`
+    const res = await fetch(url)
+    if (!res.ok || !res.body) throw new Error(`Failed to connect to ${url}: ${res.status}`)
+    const reader = res.body.getReader()
+    const decoder = new TextDecoder()
+    let buffer = ""
+    const processStream = async () => {
+      while (true) {
+        const { done, value } = await reader.read()
+        if (done) break
+        buffer += decoder.decode(value, { stream: true })
+        const lines = buffer.split("\n")
+        buffer = lines.pop() ?? ""
+        for (const line of lines) {
+          if (!line.startsWith("data:")) continue
+          const json = line.slice("data:".length).trim()
+          if (!json) continue
+          try {
+            const parsed = JSON.parse(json)
+            // Global events wrap the payload: { directory, payload: <event> }
+            const event = parsed.payload ?? parsed
+            if (event.type === "server.heartbeat" || event.type === "server.connected") continue
+            callback(event)
+          } catch {}
+        }
+      }
+    }
+    processStream()
+  }
+
+  async listProjects() {
+    const res = await this.#client.project.list()
+    if (res.error) throw new Error("Failed to list projects")
+    if (!res.data) throw new Error('No projects found')
+    return res.data
+  }
+
+  async listSessions() {
+    const res = await this.#client.session.list()
+    if (res.error) throw new Error("Failed to list sessions")
+    if (!res.data) throw new Error('No sessions found')
+    return (res.data)
+  }
+}
+
+/**
+ * Exhaustive event handler contract.
+ * Translates every OpencodeEvent into the appropriate StateStream calls.
+ */
+export type StateStreamSink = {
+  sessionCreated(info: any): void
+  sessionUpdated(info: any): void
+  sessionDeleted(info: any): void
+  sessionStatus(sessionId: string, status: { type: "idle" } | { type: "busy" } | { type: "retry"; attempt: number; message: string; next: number }): void
+  sessionIdle(sessionId: string): void
+  sessionCompacted(sessionId: string): void
+  sessionDiff(sessionId: string, diff: any[]): void
+  sessionError(sessionId: string | undefined, error: any): void
+  messageUpdated(info: any): void
+  messageRemoved(sessionId: string, messageId: string): void
+  messagePartUpdated(part: any): void
+  messagePartDelta(messageId: string, partId: string, field: string, delta: string): void
+  messagePartRemoved(sessionId: string, messageId: string, partId: string): void
+  permissionAsked(permission: PermissionRequest): void
+  permissionReplied(sessionId: string, requestId: string, reply: string): void
+  todoUpdated(sessionId: string, todos: any[]): void
+  commandExecuted(sessionId: string, name: string, args: string, messageId: string): void
+}
+
+export function handleOpencodeEvent(
+  event: OpencodeEvent,
+  sink: StateStreamSink,
+): void {
+  switch (event.type) {
+    // --- Session lifecycle ---
+    case "session.created":
+      return sink.sessionCreated(event.properties.info)
+    case "session.updated":
+      return sink.sessionUpdated(event.properties.info)
+    case "session.deleted":
+      return sink.sessionDeleted(event.properties.info)
+    case "session.status":
+      return sink.sessionStatus(event.properties.sessionID, (event.properties as any).status ?? { type: "busy" })
+    case "session.idle":
+      return sink.sessionIdle(event.properties.sessionID)
+    case "session.compacted":
+      return sink.sessionCompacted(event.properties.sessionID)
+    case "session.diff":
+      return sink.sessionDiff(event.properties.sessionID, event.properties.diff)
+    case "session.error":
+      return sink.sessionError(event.properties.sessionID, event.properties.error)
+
+    // --- Messages ---
+    case "message.updated":
+      return sink.messageUpdated(event.properties.info)
+    case "message.removed":
+      return sink.messageRemoved(event.properties.sessionID, event.properties.messageID)
+
+    // --- Message parts ---
+    case "message.part.updated":
+      return sink.messagePartUpdated(event.properties.part)
+    case "message.part.delta":
+      return sink.messagePartDelta(
+        event.properties.messageID,
+        event.properties.partID,
+        event.properties.field,
+        event.properties.delta,
+      )
+    case "message.part.removed":
+      return sink.messagePartRemoved(
+        event.properties.sessionID,
+        event.properties.messageID,
+        event.properties.partID,
+      )
+
+    // --- Permissions ---
+    case "permission.asked":
+      return sink.permissionAsked(event.properties)
+    case "permission.replied":
+      return sink.permissionReplied(
+        event.properties.sessionID,
+        event.properties.requestID,
+        event.properties.reply,
+      )
+
+    // --- Todos & commands ---
+    case "todo.updated":
+      return sink.todoUpdated(event.properties.sessionID, event.properties.todos)
+    case "command.executed":
+      return sink.commandExecuted(
+        event.properties.sessionID,
+        event.properties.name,
+        event.properties.arguments,
+        event.properties.messageID,
+      )
+
+    // --- Non-session events (no-ops for state stream) ---
+    case "server.instance.disposed":
+    case "server.connected":
+    case "global.disposed":
+    case "installation.updated":
+    case "installation.update-available":
+    case "project.updated":
+    case "lsp.client.diagnostics":
+    case "lsp.updated":
+    case "file.edited":
+    case "file.watcher.updated":
+    case "vcs.branch.updated":
+    case "tui.prompt.append":
+    case "tui.command.execute":
+    case "tui.toast.show":
+    case "tui.session.select":
+    case "mcp.tools.changed":
+    case "mcp.browser.open.failed":
+    case "pty.created":
+    case "pty.updated":
+    case "pty.exited":
+    case "pty.deleted":
+    case "question.asked":
+    case "question.replied":
+    case "question.rejected":
+    case "worktree.ready":
+    case "worktree.failed":
+      return
+
+    default: {
+      // Exhaustive check: if TypeScript complains here, a new event type
+      // was added to the SDK and needs to be handled above.
+      const _exhaustive: never = event
+      console.warn("Unhandled opencode event type:", (event as any).type)
+    }
+  }
+}

package/src/prompt.ts

@@ -0,0 +1,127 @@
+// Extracted prompt logic: resolves audio parts via transcription, then forwards to OpenCode.
+
+import type { OpencodeClient } from "./opencode"
+import { mapMessage } from "./opencode"
+import { transcribeAudio } from "./transcribe"
+import type { Message, PromptPartInput } from "./types"
+import type { StateStream } from "./state-stream"
+
+/** Line reference from the diff viewer — the user selected these lines before sending. */
+interface LineReference {
+  file: string
+  startLine: number
+  endLine: number
+  side?: "additions" | "deletions"
+}
+
+export async function sendPrompt(
+  client: OpencodeClient,
+  sessionId: string,
+  parts: PromptPartInput[],
+  directory?: string,
+  model?: { providerID: string; modelID: string },
+  agent?: string,
+  lineReference?: LineReference,
+  stateStream?: StateStream,
+  /** Client-generated message ID. When provided, the real OpenCode user message
+   *  will be created with this ID, enabling seamless client-side dedup. */
+  clientMessageId?: string,
+): Promise<void> {
+  // Fetch conversation context for audio transcription
+  let conversationContext: Message[] | undefined
+  const hasAudio = parts.some((p) => p.type === "audio")
+  if (hasAudio && clientMessageId) {
+    // Notify client that the server has the audio and transcription is starting
+    stateStream?.emitPendingTranscription(clientMessageId, sessionId, "transcribing")
+
+    try {
+      const res = await client.session.messages({ sessionID: sessionId, directory })
+      if (!res.error && res.data) {
+        conversationContext = (res.data as any[]).map(mapMessage)
+      }
+    } catch {}
+  }
+
+  const partSummary = parts.map((p) => p.type === "audio" ? "audio" : `text(${p.text.length})`).join(", ")
+  console.log(`[prompt] session=${sessionId} received ${parts.length} part(s): ${partSummary}`)
+
+  // Resolve all parts to text, transcribing audio via Gemini (in parallel)
+  const textParts = await Promise.all(
+    parts.map(async (p) => {
+      if (p.type === "audio") {
+        try {
+          const transcription = await transcribeAudio(
+            p.audioData,
+            p.mimeType ?? "audio/mp4",
+            conversationContext,
+          )
+          let text = transcription || "[inaudible]"
+
+          // Prepend per-chunk line reference if the audio part carries one
+          if (p.lineReference) {
+            const lines = p.lineReference.startLine === p.lineReference.endLine
+              ? `${p.lineReference.startLine}`
+              : `${p.lineReference.startLine}-${p.lineReference.endLine}`
+            const sideAttr = p.lineReference.side ? ` side="${p.lineReference.side}"` : ""
+            text = `<reference lines="${lines}" file="${p.lineReference.file}"${sideAttr}>\n${text}\n</reference>`
+          }
+
+          return { type: "text" as const, text }
+        } catch (err) {
+          console.error(`[prompt] transcription error:`, err)
+          return { type: "text" as const, text: "[transcription error]" }
+        }
+      }
+      return { type: "text" as const, text: p.text }
+    }),
+  )
+
+  // Notify client that transcription is complete with the resolved text
+  if (hasAudio && clientMessageId) {
+    const resolvedText = textParts.map((p) => p.text).join("\n")
+    stateStream?.emitPendingTranscription(clientMessageId, sessionId, "completed", resolvedText)
+  }
+
+  // Prepend line reference context if the user selected lines in the diff viewer
+  if (lineReference && textParts.length > 0) {
+    const lines = lineReference.startLine === lineReference.endLine
+      ? `${lineReference.startLine}`
+      : `${lineReference.startLine}-${lineReference.endLine}`
+    const sideAttr = lineReference.side ? ` side="${lineReference.side}"` : ""
+    const prefix = `<reference lines="${lines}" file="${lineReference.file}"${sideAttr}>\n`
+    const suffix = `\n</reference>`
+    textParts[0] = { type: "text", text: prefix + textParts[0].text + suffix }
+  }
+
+  const resolvedText = textParts.map((p) => p.text.slice(0, 100)).join(" | ")
+  console.log(`[prompt] session=${sessionId} forwarding to opencode: ${textParts.length} part(s), text preview: "${resolvedText.slice(0, 200)}"`)
+
+  const res = await client.session.promptAsync({
+    sessionID: sessionId,
+    directory,
+    parts: textParts,
+    // Disable the question tool — our mobile client doesn't support answering
+    // questions yet, and unanswered questions cause the session to hang.
+    // See: https://github.com/ben-pr-p/flockcode/issues/2
+    tools: { question: false },
+    ...(model ? { model } : {}),
+    ...(agent ? { agent } : {}),
+    // Use the client-generated message ID so the real user message arrives with
+    // the same ID, enabling seamless client-side dedup with the pending placeholder.
+    ...(clientMessageId ? { messageID: clientMessageId } : {}),
+  })
+  if (res.error) {
+    console.error(`[prompt] session=${sessionId} opencode error:`, res.error)
+    throw new Error(`Prompt failed: ${JSON.stringify(res.error)}`)
+  }
+
+  // Notify client the prompt has been forwarded to OpenCode.
+  // The real user message will arrive via the instance stream with the same ID,
+  // and the client's allMessages merge deduplicates by ID (server wins) —
+  // no explicit delete needed.
+  if (hasAudio && clientMessageId) {
+    stateStream?.emitPendingTranscription(clientMessageId, sessionId, "forwarded", textParts.map((p) => p.text).join("\n"))
+  }
+
+  console.log(`[prompt] session=${sessionId} prompt accepted by opencode (async)`)
+}

package/src/router/agents.ts

@@ -0,0 +1,57 @@
+import { ORPCError } from "@orpc/server"
+import { base } from "./base"
+
+export const agents = {
+  /** List available agents, pre-shaped for the client. */
+  list: base
+    .handler(async ({ context }) => {
+      try {
+        const res = await (context.client.app as any).agents()
+        if (res.error) {
+          throw new ORPCError("INTERNAL_SERVER_ERROR", {
+            message: "Failed to list agents",
+          })
+        }
+
+        const data = res.data as any
+
+        const agents: {
+          name: string
+          description?: string
+          mode: string
+          color?: string
+        }[] = []
+
+        if (data && typeof data === "object") {
+          if (Array.isArray(data)) {
+            for (const agent of data) {
+              agents.push({
+                name: agent.name ?? "",
+                description: agent.description,
+                mode: agent.mode ?? "primary",
+                color: agent.color,
+              })
+            }
+          } else {
+            for (const [key, value] of Object.entries(data)) {
+              const agent = value as any
+              agents.push({
+                name: agent.name ?? key,
+                description: agent.description,
+                mode: agent.mode ?? "primary",
+                color: agent.color,
+              })
+            }
+          }
+        }
+
+        return agents
+      } catch (err: any) {
+        if (err instanceof ORPCError) throw err
+        console.error("[agents.list]", err)
+        throw new ORPCError("INTERNAL_SERVER_ERROR", {
+          message: err.message ?? "Failed to list agents",
+        })
+      }
+    }),
+}

package/src/router/base.ts

@@ -0,0 +1,10 @@
+import { os } from "@orpc/server"
+import type { RouterContext } from "./context"
+
+/**
+ * Base procedure builder with the shared RouterContext.
+ *
+ * All router procedures should be built from this base so they
+ * automatically receive the injected context (client, appDs, etc.).
+ */
+export const base = os.$context<RouterContext>()

package/src/router/commands.ts

@@ -0,0 +1,57 @@
+import { ORPCError } from "@orpc/server"
+import { base } from "./base"
+
+export const commands = {
+  /** List available commands, pre-shaped for the client. */
+  list: base
+    .handler(async ({ context }) => {
+      try {
+        const res = await (context.client.command as any).list()
+        if (res.error) {
+          throw new ORPCError("INTERNAL_SERVER_ERROR", {
+            message: "Failed to list commands",
+          })
+        }
+
+        const data = res.data as any
+
+        const commands: {
+          name: string
+          description?: string
+          agent?: string
+          template: string
+        }[] = []
+
+        if (data && typeof data === "object") {
+          if (Array.isArray(data)) {
+            for (const cmd of data) {
+              commands.push({
+                name: cmd.name ?? "",
+                description: cmd.description,
+                agent: cmd.agent,
+                template: cmd.template ?? "",
+              })
+            }
+          } else {
+            for (const [key, value] of Object.entries(data)) {
+              const cmd = value as any
+              commands.push({
+                name: cmd.name ?? key,
+                description: cmd.description,
+                agent: cmd.agent,
+                template: cmd.template ?? "",
+              })
+            }
+          }
+        }
+
+        return commands
+      } catch (err: any) {
+        if (err instanceof ORPCError) throw err
+        console.error("[commands.list]", err)
+        throw new ORPCError("INTERNAL_SERVER_ERROR", {
+          message: err.message ?? "Failed to list commands",
+        })
+      }
+    }),
+}

package/src/router/context.ts

@@ -0,0 +1,22 @@
+import type { DurableStreamServer } from "durable-streams-web-standard"
+import type { OpencodeClient } from "../opencode"
+import type { StateStream } from "../state-stream"
+
+/**
+ * Shared context provided to every oRPC procedure.
+ *
+ * Injected at handler creation time in app.ts — procedures receive this
+ * via oRPC's context mechanism, making them independently testable.
+ */
+export interface RouterContext {
+  /** OpenCode SDK client for talking to the opencode backend. */
+  client: OpencodeClient
+  /** Persistent app-level durable stream (survives server restarts). */
+  appDs: DurableStreamServer
+  /** In-memory ephemeral durable stream (resets on server restart). */
+  ephemeralDs: DurableStreamServer
+  /** In-memory index of session → worktree mappings. */
+  sessionWorktrees: Map<string, { worktreePath: string; projectWorktree: string }>
+  /** Real-time state stream for pushing updates to connected clients. */
+  stateStream: StateStream
+}

package/src/router/diffs.ts

@@ -0,0 +1,46 @@
+import { ORPCError } from "@orpc/server"
+import { z } from "zod/v4"
+import { base } from "./base"
+
+export const diffs = {
+  /** Returns { file, before, after } for a single file in a session. */
+  get: base
+    .input(z.object({ session: z.string(), file: z.string() }))
+    .handler(async ({ input, context }) => {
+      const { session: sessionId, file } = input
+      const sessionRes = await context.client.session.get({ sessionID: sessionId })
+      const directory = sessionRes.data?.directory
+      const res = await context.client.session.diff({ sessionID: sessionId, directory })
+      if (res.error) {
+        throw new ORPCError("INTERNAL_SERVER_ERROR", {
+          message: "Failed to fetch diffs",
+        })
+      }
+      const match = (res.data ?? []).find((d: any) => d.file === file)
+      if (!match) {
+        throw new ORPCError("NOT_FOUND", {
+          message: `File not found: ${file}`,
+        })
+      }
+      return { file: match.file as string, before: match.before as string, after: match.after as string }
+    }),
+
+  /** Returns all file diffs for a session. */
+  list: base
+    .input(z.object({ session: z.string() }))
+    .handler(async ({ input, context }) => {
+      const sessionRes = await context.client.session.get({ sessionID: input.session })
+      const directory = sessionRes.data?.directory
+      const res = await context.client.session.diff({ sessionID: input.session, directory })
+      if (res.error) {
+        throw new ORPCError("INTERNAL_SERVER_ERROR", {
+          message: "Failed to fetch diffs",
+        })
+      }
+      return (res.data ?? []).map((d: any) => ({
+        file: d.file as string,
+        before: d.before as string,
+        after: d.after as string,
+      }))
+    }),
+}

package/src/router/index.ts

@@ -0,0 +1,24 @@
+import { sessions } from "./sessions"
+import { projects } from "./projects"
+import { diffs } from "./diffs"
+import { models } from "./models"
+import { agents } from "./agents"
+import { commands } from "./commands"
+import { permissions } from "./permissions"
+import { snapshot } from "./snapshot"
+
+export type { RouterContext } from "./context"
+
+/** The complete oRPC router — mounted at /api/* in the Hono app. */
+export const router = {
+  sessions,
+  projects,
+  diffs,
+  models,
+  agents,
+  commands,
+  permissions,
+  snapshot,
+}
+
+export type Router = typeof router

package/src/router/models.ts

@@ -0,0 +1,55 @@
+import { ORPCError } from "@orpc/server"
+import { base } from "./base"
+
+export const models = {
+  /** List available providers and models, pre-shaped for the client. */
+  list: base
+    .handler(async ({ context }) => {
+      try {
+        const res = await context.client.provider.list()
+        if (res.error) {
+          throw new ORPCError("INTERNAL_SERVER_ERROR", {
+            message: "Failed to list providers",
+          })
+        }
+
+        const data = res.data as any
+
+        // Extract connected provider IDs
+        const connectedSet = new Set<string>(data.connected ?? [])
+
+        // Flatten providers → models, filtering to connected providers only
+        const models: {
+          id: string
+          name: string
+          providerID: string
+          providerName: string
+          status?: string
+        }[] = []
+
+        for (const provider of data.all ?? []) {
+          if (!connectedSet.has(provider.id)) continue
+          for (const [modelId, model] of Object.entries(provider.models ?? {})) {
+            const m = model as any
+            models.push({
+              id: modelId,
+              name: m.name ?? modelId,
+              providerID: provider.id,
+              providerName: provider.name ?? provider.id,
+              status: m.status,
+            })
+          }
+        }
+
+        const defaults: Record<string, string> = data.default ?? {}
+
+        return { models, defaults }
+      } catch (err: any) {
+        if (err instanceof ORPCError) throw err
+        console.error("[models.list]", err)
+        throw new ORPCError("INTERNAL_SERVER_ERROR", {
+          message: err.message ?? "Failed to list models",
+        })
+      }
+    }),
+}