@bprp/flockcode 0.0.2

package/src/router/permissions.ts

@@ -0,0 +1,28 @@
+import { ORPCError } from "@orpc/server"
+import { z } from "zod/v4"
+import { base } from "./base"
+
+export const permissions = {
+  /** Reply to a pending permission request (approve once, always, or reject). */
+  reply: base
+    .input(z.object({
+      requestId: z.string(),
+      sessionId: z.string(),
+      reply: z.enum(["once", "always", "reject"]),
+    }))
+    .handler(async ({ input, context }) => {
+      const sessionRes = await context.client.session.get({ sessionID: input.sessionId })
+      const directory = sessionRes.data?.directory
+      const res = await context.client.permission.reply({
+        requestID: input.requestId,
+        reply: input.reply,
+        ...(directory ? { directory } : {}),
+      })
+      if ((res as any).error) {
+        throw new ORPCError("INTERNAL_SERVER_ERROR", {
+          message: "Permission reply failed",
+        })
+      }
+      return { success: true }
+    }),
+}

package/src/router/projects.ts

@@ -0,0 +1,175 @@
+import { ORPCError } from "@orpc/server"
+import { z } from "zod/v4"
+import { basename, resolve } from "node:path"
+import { customAlphabet } from "nanoid"
+import { base } from "./base"
+import { sendPrompt } from "../prompt"
+import { WorktreeDriver } from "../worktree"
+import { generateWorktreeSlug } from "../worktree-name"
+import { transcribeAudio } from "../transcribe"
+import type { Session } from "../types"
+
+const generateWorktreeId = customAlphabet("abcdefghijklmnopqrstuvwxyz0123456789", 4)
+
+export const projects = {
+  /**
+   * Create a new session for a project and send the first prompt atomically.
+   * If `useWorktree: true`, a git worktree is created first and the session
+   * runs inside it instead of the main project directory.
+   */
+  createSession: base
+    .input(z.object({
+      projectId: z.string(),
+      parts: z.array(z.union([
+        z.object({ type: z.literal("text"), text: z.string() }),
+        z.object({
+          type: z.literal("audio"),
+          audioData: z.string(),
+          mimeType: z.string().optional(),
+          lineReference: z.object({
+            file: z.string(),
+            startLine: z.number(),
+            endLine: z.number(),
+            side: z.enum(["additions", "deletions"]).optional(),
+          }).optional(),
+        }),
+      ])),
+      model: z.object({ providerID: z.string(), modelID: z.string() }).optional(),
+      agent: z.string().optional(),
+      useWorktree: z.boolean().optional(),
+      /** Client-generated message ID for voice messages. */
+      clientMessageId: z.string().optional(),
+    }))
+    .handler(async ({ input, context }) => {
+      const { projectId, parts, model, useWorktree, agent, clientMessageId } = input
+
+      // Look up the project to get its worktree
+      const projectsRes = await context.client.project.list()
+      const project = (projectsRes.data ?? []).find((p: any) => p.id === projectId)
+      if (!project) {
+        throw new ORPCError("NOT_FOUND", {
+          message: `Project not found: ${projectId}`,
+        })
+      }
+
+      // Determine the directory for this session
+      let directory: string = project.worktree
+      let worktreePath: string | undefined
+
+      if (useWorktree) {
+        try {
+          // Extract text from prompt parts — transcribe audio if needed
+          let promptText = parts
+            .filter((p): p is { type: "text"; text: string } => p.type === "text")
+            .map((p) => p.text)
+            .join(" ")
+            .trim()
+
+          if (!promptText) {
+            const audioPart = parts.find(
+              (p): p is { type: "audio"; audioData: string; mimeType?: string } => p.type === "audio"
+            )
+            if (audioPart) {
+              promptText = await transcribeAudio(audioPart.audioData, audioPart.mimeType ?? "audio/aac")
+            }
+          }
+
+          const slug = await generateWorktreeSlug(promptText)
+          const worktreeId = `${generateWorktreeId()}-${slug}`
+          const projectName = basename(project.worktree)
+          // Place worktrees at ../worktrees/<project-name>/<id> relative to project root
+          const targetPath = resolve(project.worktree, "..", "worktrees", projectName, worktreeId)
+          const branchName = `worktree/${worktreeId}`
+
+          const driver = await WorktreeDriver.open(project.worktree)
+          await driver.create(branchName, { path: targetPath })
+
+          directory = targetPath
+          worktreePath = targetPath
+        } catch (err: any) {
+          console.error("[projects.createSession] worktree creation failed:", err)
+          throw new ORPCError("INTERNAL_SERVER_ERROR", {
+            message: `Failed to create worktree: ${err.message}`,
+          })
+        }
+      }
+
+      // Create the session in the chosen directory
+      const createRes = await context.client.session.create({
+        directory,
+      })
+      if (createRes.error) {
+        throw new ORPCError("INTERNAL_SERVER_ERROR", {
+          message: "Failed to create session",
+        })
+      }
+      const sessionId = createRes.data!.id
+
+      // Persist the session→worktree mapping so we can clean up on delete
+      if (worktreePath) {
+        context.sessionWorktrees.set(sessionId, { worktreePath, projectWorktree: project.worktree })
+        await context.appDs.appendToStream("/", JSON.stringify({
+          type: "sessionWorktree",
+          key: sessionId,
+          value: { sessionId, worktreePath, projectWorktree: project.worktree },
+          headers: { operation: "upsert" },
+        }), { contentType: "application/json" })
+      }
+
+      // Confirm upload if client provided a message ID
+      if (clientMessageId) {
+        context.stateStream.emitPendingTranscription(clientMessageId, sessionId, "upload-confirmed")
+      }
+
+      // Fire the prompt in the background — don't block the response.
+      // The client navigates to the session immediately and sees streaming
+      // updates via the SSE durable stream. Pending transcription events are
+      // emitted to the ephemeral stream so the client can show progress.
+      sendPrompt(context.client, sessionId, parts, directory, model, agent, undefined, context.stateStream, clientMessageId).catch(
+        (err: any) => {
+          console.error("[projects.createSession] prompt failed:", err)
+        },
+      )
+
+      return { sessionId }
+    }),
+
+  /** List sessions for a project (queries main worktree + all git worktrees). */
+  listSessions: base
+    .input(z.object({ projectId: z.string() }))
+    .handler(async ({ input, context }) => {
+      const { projectId } = input
+
+      // Look up the project to get its worktree
+      const projectsRes = await context.client.project.list()
+      const project = (projectsRes.data ?? []).find((p: any) => p.id === projectId)
+      if (!project) {
+        throw new ORPCError("NOT_FOUND", {
+          message: `Project not found: ${projectId}`,
+        })
+      }
+
+      // Collect all directories: main worktree + any git worktrees
+      const directories: string[] = [project.worktree]
+      try {
+        const driver = await WorktreeDriver.open(project.worktree)
+        const entries = await driver.list()
+        for (const entry of entries) {
+          if (entry.path !== project.worktree) {
+            directories.push(entry.path)
+          }
+        }
+      } catch {
+        // Not a git repo or worktree listing failed — just use main directory
+      }
+
+      // Query sessions for each directory in parallel
+      const results = await Promise.all(
+        directories.map(async (dir) => {
+          const res = await context.client.session.list({ directory: dir })
+          return ((res.data ?? []) as Session[])
+        })
+      )
+      return results.flat().sort((a, b) => b.time.updated - a.time.updated)
+    }),
+}

package/src/router/sessions.ts

@@ -0,0 +1,316 @@
+import { ORPCError } from "@orpc/server"
+import { z } from "zod/v4"
+import { base } from "./base"
+import { sendPrompt } from "../prompt"
+import { handleVoicePrompt } from "../voice-prompt"
+import { WorktreeDriver } from "../worktree"
+
+export const sessions = {
+  /** Send a prompt to an existing session. */
+  prompt: base
+    .input(z.object({
+      sessionId: z.string(),
+      parts: z.array(z.union([
+        z.object({ type: z.literal("text"), text: z.string() }),
+        z.object({
+          type: z.literal("audio"),
+          audioData: z.string(),
+          mimeType: z.string().optional(),
+          lineReference: z.object({
+            file: z.string(),
+            startLine: z.number(),
+            endLine: z.number(),
+            side: z.enum(["additions", "deletions"]).optional(),
+          }).optional(),
+        }),
+      ])),
+      model: z.object({ providerID: z.string(), modelID: z.string() }).optional(),
+      agent: z.string().optional(),
+      lineReference: z.object({
+        file: z.string(),
+        startLine: z.number(),
+        endLine: z.number(),
+        side: z.enum(["additions", "deletions"]).optional(),
+      }).optional(),
+      /** Client-generated message ID for voice messages. Enables server-side
+       *  transcription status tracking and seamless client-side dedup. */
+      clientMessageId: z.string().optional(),
+    }))
+    .handler(async ({ input, context }) => {
+      const { sessionId, parts, model, agent, lineReference, clientMessageId } = input
+      try {
+        const sessionRes = await context.client.session.get({ sessionID: sessionId })
+        const directory = sessionRes.data?.directory
+        const hasAudio = parts.some((p) => p.type === "audio")
+
+        if (hasAudio && clientMessageId) {
+          // Confirm upload — client can now show "safe to navigate away"
+          context.stateStream.emitPendingTranscription(clientMessageId, sessionId, "upload-confirmed")
+        }
+
+        if (hasAudio) {
+          // For audio prompts, return immediately and run transcription in the background.
+          // The client tracks progress via pending transcription events on the ephemeral stream.
+          sendPrompt(context.client, sessionId, parts, directory, model, agent, lineReference, context.stateStream, clientMessageId).catch(
+            (err: any) => {
+              console.error("[sessions.prompt] background audio prompt failed:", err)
+            },
+          )
+          return { success: true as const }
+        }
+        // Text-only prompts are fast — await them inline
+        await sendPrompt(context.client, sessionId, parts, directory, model, agent, lineReference, context.stateStream, clientMessageId)
+        return { success: true as const }
+      } catch (err: any) {
+        console.error("[sessions.prompt]", err)
+        throw new ORPCError("INTERNAL_SERVER_ERROR", {
+          message: err.message ?? "Prompt failed",
+        })
+      }
+    }),
+
+  /** Abort a currently running session. */
+  abort: base
+    .input(z.object({ sessionId: z.string() }))
+    .handler(async ({ input, context }) => {
+      const { sessionId } = input
+      try {
+        const sessionRes = await context.client.session.get({ sessionID: sessionId })
+        const directory = sessionRes.data?.directory
+        const res = await context.client.session.abort({
+          sessionID: sessionId,
+          ...(directory ? { directory } : {}),
+        })
+        if (res.error) {
+          throw new ORPCError("INTERNAL_SERVER_ERROR", {
+            message: "Failed to abort session",
+          })
+        }
+        return { success: true as const }
+      } catch (err: any) {
+        if (err instanceof ORPCError) throw err
+        console.error("[sessions.abort]", err)
+        throw new ORPCError("INTERNAL_SERVER_ERROR", {
+          message: err.message ?? "Abort failed",
+        })
+      }
+    }),
+
+  /** Delete a session permanently (and remove its worktree if one exists). */
+  delete: base
+    .input(z.object({ sessionId: z.string() }))
+    .handler(async ({ input, context }) => {
+      const { sessionId } = input
+      try {
+        const sessionRes = await context.client.session.get({ sessionID: sessionId })
+        const directory = sessionRes.data?.directory
+
+        const res = await context.client.session.delete({
+          sessionID: sessionId,
+          ...(directory ? { directory } : {}),
+        })
+        if (res.error) {
+          throw new ORPCError("INTERNAL_SERVER_ERROR", {
+            message: "Failed to delete session",
+          })
+        }
+
+        // Push the deletion through the durable stream immediately so
+        // connected clients see it without waiting for the SSE event.
+        context.stateStream.sessionDeleted({ id: sessionId })
+
+        // Clean up the git worktree if this session had one
+        const worktreeInfo = context.sessionWorktrees.get(sessionId)
+        if (worktreeInfo) {
+          try {
+            const driver = await WorktreeDriver.open(worktreeInfo.projectWorktree)
+            await driver.remove(worktreeInfo.worktreePath, { force: true, deleteBranch: true })
+          } catch (err: any) {
+            // Log but don't fail the delete — the session is already gone
+            console.error(`[sessions.delete] worktree cleanup failed:`, err)
+          }
+          context.sessionWorktrees.delete(sessionId)
+        }
+
+        return { success: true as const }
+      } catch (err: any) {
+        if (err instanceof ORPCError) throw err
+        console.error("[sessions.delete]", err)
+        throw new ORPCError("INTERNAL_SERVER_ERROR", {
+          message: err.message ?? "Delete failed",
+        })
+      }
+    }),
+
+  /** Execute a command on a session. */
+  command: base
+    .input(z.object({
+      sessionId: z.string(),
+      command: z.string(),
+      arguments: z.string(),
+      agent: z.string().optional(),
+      model: z.object({ providerID: z.string(), modelID: z.string() }).optional(),
+    }))
+    .handler(async ({ input, context }) => {
+      const { sessionId, command, arguments: args, agent, model } = input
+      try {
+        const sessionRes = await context.client.session.get({ sessionID: sessionId })
+        const directory = sessionRes.data?.directory
+        const res = await context.client.session.command({
+          sessionID: sessionId,
+          directory,
+          command,
+          arguments: args,
+          ...(agent ? { agent } : {}),
+          ...(model ? { model: `${model.providerID}/${model.modelID}` } : {}),
+        })
+        if (res.error) {
+          throw new ORPCError("INTERNAL_SERVER_ERROR", {
+            message: "Command failed",
+          })
+        }
+        return { success: true as const }
+      } catch (err: any) {
+        if (err instanceof ORPCError) throw err
+        console.error("[sessions.command]", err)
+        throw new ORPCError("INTERNAL_SERVER_ERROR", {
+          message: err.message ?? "Command failed",
+        })
+      }
+    }),
+
+  /** Walking-mode voice prompt: transcribe, route, optionally respond with TTS. */
+  voicePrompt: base
+    .input(z.object({
+      sessionId: z.string(),
+      audioData: z.string(),
+      mimeType: z.string().optional(),
+      model: z.object({ providerID: z.string(), modelID: z.string() }).optional(),
+    }))
+    .handler(async ({ input, context }) => {
+      const { sessionId, audioData, mimeType, model } = input
+      try {
+        const sessionRes = await context.client.session.get({ sessionID: sessionId })
+        const directory = sessionRes.data?.directory
+        return await handleVoicePrompt(
+          context.client,
+          sessionId,
+          audioData,
+          mimeType ?? "audio/x-caf",
+          directory,
+          model,
+        )
+      } catch (err: any) {
+        if (err instanceof ORPCError) throw err
+        console.error("[sessions.voicePrompt]", err)
+        throw new ORPCError("INTERNAL_SERVER_ERROR", {
+          message: err.message ?? "Voice prompt failed",
+        })
+      }
+    }),
+
+  /** Archive a session (persistent app state). */
+  archive: base
+    .input(z.object({ sessionId: z.string() }))
+    .handler(async ({ input, context }) => {
+      await context.appDs.appendToStream("/", JSON.stringify({
+        type: "sessionMeta",
+        key: input.sessionId,
+        value: { sessionId: input.sessionId, archived: true },
+        headers: { operation: "upsert" },
+      }), { contentType: "application/json" })
+      return { success: true as const }
+    }),
+
+  /** Unarchive a session (persistent app state). */
+  unarchive: base
+    .input(z.object({ sessionId: z.string() }))
+    .handler(async ({ input, context }) => {
+      await context.appDs.appendToStream("/", JSON.stringify({
+        type: "sessionMeta",
+        key: input.sessionId,
+        value: { sessionId: input.sessionId, archived: false },
+        headers: { operation: "upsert" },
+      }), { contentType: "application/json" })
+      return { success: true as const }
+    }),
+
+  /** Check the merge status for a worktree session. */
+  mergeStatus: base
+    .input(z.object({ sessionId: z.string() }))
+    .handler(async ({ input, context }) => {
+      const worktreeInfo = context.sessionWorktrees.get(input.sessionId)
+      if (!worktreeInfo) {
+        return { isWorktreeSession: false as const }
+      }
+
+      try {
+        const driver = await WorktreeDriver.open(worktreeInfo.projectWorktree)
+        const branch = await driver.branchForPath(worktreeInfo.worktreePath)
+        if (!branch) {
+          return { isWorktreeSession: true as const, error: "Could not resolve branch for worktree" }
+        }
+
+        const merged = await driver.isMerged(branch, "main")
+        const hasUnmerged = await driver.hasUnmergedCommits(branch, "main")
+
+        return {
+          isWorktreeSession: true as const,
+          branch,
+          merged,
+          hasUnmergedCommits: hasUnmerged,
+        }
+      } catch (err: any) {
+        console.error(`[sessions.mergeStatus]`, err)
+        return { isWorktreeSession: true as const, error: err.message ?? "Failed to check merge status" }
+      }
+    }),
+
+  /** Merge a worktree session's branch into main. */
+  merge: base
+    .input(z.object({ sessionId: z.string() }))
+    .handler(async ({ input, context }) => {
+      const worktreeInfo = context.sessionWorktrees.get(input.sessionId)
+      if (!worktreeInfo) {
+        throw new ORPCError("BAD_REQUEST", {
+          message: "Session does not have an associated worktree",
+        })
+      }
+
+      try {
+        const driver = await WorktreeDriver.open(worktreeInfo.projectWorktree)
+        const branch = await driver.branchForPath(worktreeInfo.worktreePath)
+        if (!branch) {
+          throw new ORPCError("BAD_REQUEST", {
+            message: "Could not resolve branch for worktree",
+          })
+        }
+
+        // Dry-run: check for conflicts before attempting the real merge
+        const check = await driver.canMerge(branch, "main")
+        if (!check.ok) {
+          throw new ORPCError("CONFLICT", {
+            message: "Merge would conflict",
+            data: {
+              reason: check.reason,
+              conflictingFiles: check.conflictingFiles,
+            },
+          })
+        }
+
+        // Real merge: --no-ff into main (default)
+        await driver.merge(branch, { into: "main" })
+
+        // Push updated worktree status through the stream
+        context.stateStream.refreshWorktreeStatus(input.sessionId)
+
+        return { success: true as const, branch }
+      } catch (err: any) {
+        if (err instanceof ORPCError) throw err
+        console.error(`[sessions.merge]`, err)
+        throw new ORPCError("INTERNAL_SERVER_ERROR", {
+          message: err.message ?? "Merge failed",
+        })
+      }
+    }),
+}

package/src/router/snapshot.ts

@@ -0,0 +1,9 @@
+import { base } from "./base"
+
+export const snapshot = {
+  /** Return materialized ephemeral state so clients can bootstrap without replaying history. */
+  ephemeral: base
+    .handler(async ({ context }) => {
+      return context.stateStream.getEphemeralSnapshot()
+    }),
+}

package/src/server.ts

@@ -0,0 +1,15 @@
+#!/usr/bin/env bun
+/**
+ * Standalone Bun HTTP server entrypoint for `bun run dev` / `bun run start`.
+ *
+ * Reads configuration from environment variables only (no CLI arg parsing).
+ * The CLI entrypoint (`index.ts`) calls {@link startServer} directly.
+ */
+
+import { startServer } from "./start-server"
+import { env } from "./env"
+
+export const { app, instanceDs, ephemeralDs, appDs, stateStream, instanceId, server } = await startServer({
+  opencodeUrl: env.OPENCODE_URL || undefined,
+  port: env.PORT,
+})