fix: drop session diff patches from tui cache

Allows beta releases to include properly signed Windows CLI executables, ensuring consistent security verification across all release channels.

.github/workflows/publish.yml

@@ -114,7 +114,7 @@ jobs:
       - build-cli
       - version
     runs-on: blacksmith-4vcpu-windows-2025
-    if: github.repository == 'anomalyco/opencode' && github.ref_name != 'beta'
+    if: github.repository == 'anomalyco/opencode'
     env:
       AZURE_CLIENT_ID: ${{ secrets.AZURE_CLIENT_ID }}
       AZURE_TENANT_ID: ${{ secrets.AZURE_TENANT_ID }}
@@ -591,7 +591,6 @@ jobs:
           path: packages/opencode/dist
 
       - uses: actions/download-artifact@v4
-        if: github.ref_name != 'beta'
         with:
           name: opencode-cli-signed-windows
           path: packages/opencode/dist

packages/opencode/src/cli/cmd/tui/app.tsx

@@ -59,7 +59,6 @@ import { TuiConfigProvider, useTuiConfig } from "./context/tui-config"
 import { TuiConfig } from "@/config/tui"
 import { createTuiApi, TuiPluginRuntime, type RouteMap } from "./plugin"
 import { FormatError, FormatUnknownError } from "@/cli/error"
-import { Keybind } from "@/util/keybind"
 
 async function getTerminalBackgroundColor(): Promise<"dark" | "light"> {
   // can't set raw mode if not a TTY
@@ -311,7 +310,7 @@ function App(props: { onSnapshot?: () => Promise<string[]> }) {
     // - Ctrl+C copies and dismisses selection
     // - Esc dismisses selection
     // - Most other key input dismisses selection and is passed through
-    if (Keybind.matchParsedKey("ctrl+c", evt)) {
+    if (evt.ctrl && evt.name === "c") {
       if (!Selection.copy(renderer, toast)) {
         renderer.clearSelection()
         return

packages/opencode/src/cli/cmd/tui/component/dialog-mcp.tsx

@@ -47,7 +47,7 @@ export function DialogMcp() {
 
   const keybinds = createMemo(() => [
     {
-      keybind: Keybind.parseOne("space"),
+      keybind: Keybind.parse("space")[0],
       title: "toggle",
       onTrigger: async (option: DialogSelectOption<string>) => {
         // Prevent toggling while an operation is already in progress

packages/opencode/src/cli/cmd/tui/component/dialog-session-list.tsx

@@ -162,7 +162,7 @@ export function DialogSessionList() {
           },
         },
         {
-          keybind: Keybind.parseOne("ctrl+w"),
+          keybind: Keybind.parse("ctrl+w")[0],
           title: "new workspace",
           side: "right",
           disabled: !Flag.OPENCODE_EXPERIMENTAL_WORKSPACES,

packages/opencode/src/cli/cmd/tui/component/error-component.tsx

@@ -5,7 +5,6 @@ import { createSignal } from "solid-js"
 import { Installation } from "@/installation"
 import { win32FlushInputBuffer } from "../win32"
 import { getScrollAcceleration } from "../util/scroll"
-import { Keybind } from "@/util/keybind"
 
 export function ErrorComponent(props: {
   error: Error
@@ -26,7 +25,7 @@ export function ErrorComponent(props: {
   }
 
   useKeyboard((evt) => {
-    if (Keybind.matchParsedKey("ctrl+c", evt)) {
+    if (evt.ctrl && evt.name === "c") {
       handleExit()
     }
   })

packages/opencode/src/cli/cmd/tui/context/sync.tsx

@@ -31,6 +31,16 @@ import { batch, createEffect, on } from "solid-js"
 import { Log } from "@/util/log"
 import { ConsoleState, emptyConsoleState, type ConsoleState as ConsoleStateType } from "@/config/console-state"
 
+type SessionDiffSummary = Pick<Snapshot.FileDiff, "file" | "additions" | "deletions">
+
+function summarizeDiff(diff?: Snapshot.FileDiff[]): SessionDiffSummary[] {
+  return (diff ?? []).map((item) => ({
+    file: item.file,
+    additions: item.additions,
+    deletions: item.deletions,
+  }))
+}
+
 export const { use: useSync, provider: SyncProvider } = createSimpleContext({
   name: "Sync",
   init: () => {
@@ -55,7 +65,7 @@ export const { use: useSync, provider: SyncProvider } = createSimpleContext({
         [sessionID: string]: SessionStatus
       }
       session_diff: {
-        [sessionID: string]: Snapshot.FileDiff[]
+        [sessionID: string]: SessionDiffSummary[]
       }
       todo: {
         [sessionID: string]: Todo[]
@@ -193,7 +203,7 @@ export const { use: useSync, provider: SyncProvider } = createSimpleContext({
           break
 
         case "session.diff":
-          setStore("session_diff", event.properties.sessionID, event.properties.diff)
+          setStore("session_diff", event.properties.sessionID, summarizeDiff(event.properties.diff))
           break
 
         case "session.deleted": {
@@ -503,7 +513,7 @@ export const { use: useSync, provider: SyncProvider } = createSimpleContext({
               for (const message of messages.data!) {
                 draft.part[message.info.id] = message.parts
               }
-              draft.session_diff[sessionID] = diff.data ?? []
+              draft.session_diff[sessionID] = summarizeDiff(diff.data)
             }),
           )
           fullSyncedSessions.add(sessionID)

packages/opencode/src/cli/cmd/tui/ui/dialog-select.tsx

@@ -195,8 +195,8 @@ export function DialogSelect<T>(props: DialogSelectProps<T>) {
   useKeyboard((evt) => {
     setStore("input", "keyboard")
 
-    if (evt.name === "up" || Keybind.matchParsedKey("ctrl+p", evt)) move(-1)
-    if (evt.name === "down" || Keybind.matchParsedKey("ctrl+n", evt)) move(1)
+    if (evt.name === "up" || (evt.ctrl && evt.name === "p")) move(-1)
+    if (evt.name === "down" || (evt.ctrl && evt.name === "n")) move(1)
     if (evt.name === "pageup") move(-10)
     if (evt.name === "pagedown") move(10)
     if (evt.name === "home") moveTo(0)

packages/opencode/src/cli/cmd/tui/ui/dialog.tsx

@@ -6,7 +6,6 @@ import { createStore } from "solid-js/store"
 import { useToast } from "./toast"
 import { Flag } from "@/flag/flag"
 import { Selection } from "@tui/util/selection"
-import { Keybind } from "@/util/keybind"
 
 export function Dialog(
   props: ParentProps<{
@@ -73,13 +72,12 @@ function init() {
   })
 
   const renderer = useRenderer()
+
   useKeyboard((evt) => {
     if (store.stack.length === 0) return
     if (evt.defaultPrevented) return
-    const isCtrlC = Keybind.matchParsedKey("ctrl+c", evt)
-
-    if ((evt.name === "escape" || isCtrlC) && renderer.getSelection()?.getSelectedText()) return
-    if (evt.name === "escape" || isCtrlC) {
+    if ((evt.name === "escape" || (evt.ctrl && evt.name === "c")) && renderer.getSelection()?.getSelectedText()) return
+    if (evt.name === "escape" || (evt.ctrl && evt.name === "c")) {
       if (renderer.getSelection()) {
         renderer.clearSelection()
       }

packages/opencode/src/util/keybind.ts

@@ -6,70 +6,15 @@ export namespace Keybind {
    * Keybind info derived from OpenTUI's ParsedKey with our custom `leader` field.
    * This ensures type compatibility and catches missing fields at compile time.
    */
-  export type Info = Pick<ParsedKey, "name" | "ctrl" | "meta" | "shift" | "super" | "baseCode"> & {
+  export type Info = Pick<ParsedKey, "name" | "ctrl" | "meta" | "shift" | "super"> & {
     leader: boolean // our custom field
   }
 
-  function getBaseCodeName(baseCode: number | undefined): string | undefined {
-    if (baseCode === undefined || baseCode < 32 || baseCode === 127) {
-      return undefined
-    }
-
-    try {
-      const name = String.fromCodePoint(baseCode)
-
-      if (name.length === 1 && name >= "A" && name <= "Z") {
-        return name.toLowerCase()
-      }
-
-      return name
-    } catch {
-      return undefined
-    }
-  }
-
   export function match(a: Info | undefined, b: Info): boolean {
     if (!a) return false
     const normalizedA = { ...a, super: a.super ?? false }
     const normalizedB = { ...b, super: b.super ?? false }
-    if (isDeepEqual(normalizedA, normalizedB)) {
-      return true
-    }
-
-    const modifiersA = {
-      ctrl: normalizedA.ctrl,
-      meta: normalizedA.meta,
-      shift: normalizedA.shift,
-      super: normalizedA.super,
-      leader: normalizedA.leader,
-    }
-    const modifiersB = {
-      ctrl: normalizedB.ctrl,
-      meta: normalizedB.meta,
-      shift: normalizedB.shift,
-      super: normalizedB.super,
-      leader: normalizedB.leader,
-    }
-
-    if (!isDeepEqual(modifiersA, modifiersB)) {
-      return false
-    }
-
-    return (
-      normalizedA.name === normalizedB.name ||
-      getBaseCodeName(normalizedA.baseCode) === normalizedB.name ||
-      getBaseCodeName(normalizedB.baseCode) === normalizedA.name
-    )
-  }
-
-  export function parseOne(key: string): Info {
-    const parsed = parse(key)
-
-    if (parsed.length !== 1) {
-      throw new Error(`Expected exactly one keybind, got ${parsed.length}: ${key}`)
-    }
-
-    return parsed[0]!
+    return isDeepEqual(normalizedA, normalizedB)
   }
 
   /**
@@ -83,23 +28,10 @@ export namespace Keybind {
       meta: key.meta,
       shift: key.shift,
       super: key.super ?? false,
-      baseCode: key.baseCode,
       leader,
     }
   }
 
-  export function matchParsedKey(binding: Info | string | undefined, key: ParsedKey, leader = false): boolean {
-    const bindings = typeof binding === "string" ? parse(binding) : binding ? [binding] : []
-
-    if (!bindings.length) {
-      return false
-    }
-
-    const parsed = fromParsedKey(key, leader)
-
-    return bindings.some((item) => match(item, parsed))
-  }
-
   export function toString(info: Info | undefined): string {
     if (!info) return ""
     const parts: string[] = []

packages/opencode/src/v2/message.ts

@@ -10,59 +10,106 @@ export namespace Message {
     })),
   )
 
-  export class File extends Schema.Class<File>("Message.File")({
-    url: Schema.String,
+  export class Source extends Schema.Class<Source>("Message.Source")({
+    start: Schema.Number,
+    end: Schema.Number,
+    text: Schema.String,
+  }) {}
+
+  export class FileAttachment extends Schema.Class<FileAttachment>("Message.File.Attachment")({
+    uri: Schema.String,
     mime: Schema.String,
+    name: Schema.String.pipe(Schema.optional),
+    description: Schema.String.pipe(Schema.optional),
+    source: Source.pipe(Schema.optional),
   }) {
     static create(url: string) {
-      return new File({
-        url,
+      return new FileAttachment({
+        uri: url,
         mime: "text/plain",
       })
     }
   }
 
-  export class UserContent extends Schema.Class<UserContent>("Message.User.Content")({
-    text: Schema.String,
-    synthetic: Schema.Boolean.pipe(Schema.optional),
-    agent: Schema.String.pipe(Schema.optional),
-    files: Schema.Array(File).pipe(Schema.optional),
+  export class AgentAttachment extends Schema.Class<AgentAttachment>("Message.Agent.Attachment")({
+    name: Schema.String,
+    source: Source.pipe(Schema.optional),
   }) {}
 
   export class User extends Schema.Class<User>("Message.User")({
     id: ID,
     type: Schema.Literal("user"),
+    text: Schema.String,
+    files: Schema.Array(FileAttachment).pipe(Schema.optional),
+    agents: Schema.Array(AgentAttachment).pipe(Schema.optional),
     time: Schema.Struct({
       created: Schema.DateTimeUtc,
     }),
-    content: UserContent,
   }) {
-    static create(content: Schema.Schema.Type<typeof UserContent>) {
+    static create(input: { text: User["text"]; files?: User["files"]; agents?: User["agents"] }) {
       const msg = new User({
         id: ID.create(),
         type: "user",
+        ...input,
         time: {
           created: Effect.runSync(DateTime.now),
         },
-        content,
       })
       return msg
     }
-
-    static file(url: string) {
-      return new File({
-        url,
-        mime: "text/plain",
-      })
-    }
   }
 
-  export namespace User {}
+  export class Synthetic extends Schema.Class<Synthetic>("Message.Synthetic")({
+    id: ID,
+    type: Schema.Literal("synthetic"),
+    text: Schema.String,
+    time: Schema.Struct({
+      created: Schema.DateTimeUtc,
+    }),
+  }) {}
+
+  export class Request extends Schema.Class<Request>("Message.Request")({
+    id: ID,
+    type: Schema.Literal("start"),
+    model: Schema.Struct({
+      id: Schema.String,
+      providerID: Schema.String,
+      variant: Schema.String.pipe(Schema.optional),
+    }),
+    time: Schema.Struct({
+      created: Schema.DateTimeUtc,
+    }),
+  }) {}
+
+  export class Text extends Schema.Class<Text>("Message.Text")({
+    id: ID,
+    type: Schema.Literal("text"),
+    text: Schema.String,
+    time: Schema.Struct({
+      created: Schema.DateTimeUtc,
+      completed: Schema.DateTimeUtc.pipe(Schema.optional),
+    }),
+  }) {}
+
+  export class Complete extends Schema.Class<Complete>("Message.Complete")({
+    id: ID,
+    type: Schema.Literal("complete"),
+    time: Schema.Struct({
+      created: Schema.DateTimeUtc,
+    }),
+    cost: Schema.Number,
+    tokens: Schema.Struct({
+      total: Schema.Number,
+      input: Schema.Number,
+      output: Schema.Number,
+      reasoning: Schema.Number,
+      cache: Schema.Struct({
+        read: Schema.Number,
+        write: Schema.Number,
+      }),
+    }),
+  }) {}
+
+  export const Info = Schema.Union([User, Text])
+  export type Info = Schema.Schema.Type<typeof Info>
 }
-
-const msg = Message.User.create({
-  text: "Hello world",
-  files: [Message.File.create("file://example.com/file.txt")],
-})
-
-console.log(JSON.stringify(msg, null, 2))

packages/opencode/src/v2/session.ts

@@ -0,0 +1,71 @@
+import { Context, Layer, Schema, Effect } from "effect"
+import { Message } from "./message"
+import { Struct } from "effect"
+import { Identifier } from "@/id/id"
+import { withStatics } from "@/util/schema"
+import { Session } from "@/session"
+import { SessionID } from "@/session/schema"
+
+export namespace SessionV2 {
+  export const ID = SessionID
+
+  export type ID = Schema.Schema.Type<typeof ID>
+
+  export class PromptInput extends Schema.Class<PromptInput>("Session.PromptInput")({
+    ...Struct.omit(Message.User.fields, ["time", "type"]),
+    id: Schema.optionalKey(Message.ID),
+    sessionID: SessionV2.ID,
+  }) {}
+
+  export class CreateInput extends Schema.Class<CreateInput>("Session.CreateInput")({
+    id: Schema.optionalKey(SessionV2.ID),
+  }) {}
+
+  export class Info extends Schema.Class<Info>("Session.Info")({
+    id: SessionV2.ID,
+    model: Schema.Struct({
+      id: Schema.String,
+      providerID: Schema.String,
+      modelID: Schema.String,
+    }).pipe(Schema.optional),
+  }) {}
+
+  export interface Interface {
+    fromID: (id: SessionV2.ID) => Effect.Effect<Info>
+    create: (input: CreateInput) => Effect.Effect<Info>
+    prompt: (input: PromptInput) => Effect.Effect<Message.User>
+  }
+
+  export class Service extends Context.Service<Service, Interface>()("Session.Service") {}
+
+  export const layer = Layer.effect(Service)(
+    Effect.gen(function* () {
+      const session = yield* Session.Service
+
+      const create: Interface["create"] = Effect.fn("Session.create")(function* (input) {
+        throw new Error("Not implemented")
+      })
+
+      const prompt: Interface["prompt"] = Effect.fn("Session.prompt")(function* (input) {
+        throw new Error("Not implemented")
+      })
+
+      const fromID: Interface["fromID"] = Effect.fn("Session.fromID")(function* (id) {
+        const match = yield* session.get(id)
+        return fromV1(match)
+      })
+
+      return Service.of({
+        create,
+        prompt,
+        fromID,
+      })
+    }),
+  )
+
+  function fromV1(input: Session.Info): Info {
+    return new Info({
+      id: SessionV2.ID.make(input.id),
+    })
+  }
+}

packages/opencode/test/cli/tui/sync-provider.test.tsx

@@ -270,6 +270,7 @@ describe("SyncProvider", () => {
       expect(sync.data.message.ses_1[0]?.id).toBe("msg_1")
       expect(sync.data.part.msg_1[0]).toMatchObject({ type: "text", text: "part-ws_a" })
       expect(sync.data.session_diff.ses_1[0]?.file).toBe("ws_a.ts")
+      expect(sync.data.session_diff.ses_1[0]).not.toHaveProperty("patch")
 
       log.length = 0
       project.workspace.set("ws_b")
@@ -285,6 +286,7 @@ describe("SyncProvider", () => {
       expect(sync.data.message.ses_1[0]?.id).toBe("msg_1")
       expect(sync.data.part.msg_1[0]).toMatchObject({ type: "text", text: "part-ws_b" })
       expect(sync.data.session_diff.ses_1[0]?.file).toBe("ws_b.ts")
+      expect(sync.data.session_diff.ses_1[0]).not.toHaveProperty("patch")
     } finally {
       app.renderer.destroy()
     }

packages/opencode/test/keybind.test.ts

@@ -162,24 +162,6 @@ describe("Keybind.match", () => {
     expect(Keybind.match(a, b)).toBe(true)
   })
 
-  test("should match ctrl shortcuts by baseCode from alternate layouts", () => {
-    const a: Keybind.Info = { ctrl: true, meta: false, shift: false, leader: false, name: "c" }
-    const b: Keybind.Info = { ctrl: true, meta: false, shift: false, leader: false, name: "ㅊ", baseCode: 99 }
-    expect(Keybind.match(a, b)).toBe(true)
-  })
-
-  test("should still match the reported character when baseCode is also present", () => {
-    const a: Keybind.Info = { ctrl: true, meta: false, shift: false, leader: false, name: "ㅊ" }
-    const b: Keybind.Info = { ctrl: true, meta: false, shift: false, leader: false, name: "ㅊ", baseCode: 99 }
-    expect(Keybind.match(a, b)).toBe(true)
-  })
-
-  test("should not match a different shortcut just because baseCode exists", () => {
-    const a: Keybind.Info = { ctrl: true, meta: false, shift: false, leader: false, name: "x" }
-    const b: Keybind.Info = { ctrl: true, meta: false, shift: false, leader: false, name: "ㅊ", baseCode: 99 }
-    expect(Keybind.match(a, b)).toBe(false)
-  })
-
   test("should match super+shift combination", () => {
     const a: Keybind.Info = { ctrl: false, meta: false, shift: true, super: true, leader: false, name: "z" }
     const b: Keybind.Info = { ctrl: false, meta: false, shift: true, super: true, leader: false, name: "z" }
@@ -437,68 +419,3 @@ describe("Keybind.parse", () => {
     ])
   })
 })
-
-describe("Keybind.parseOne", () => {
-  test("should parse a single keybind", () => {
-    expect(Keybind.parseOne("ctrl+x")).toEqual({
-      ctrl: true,
-      meta: false,
-      shift: false,
-      leader: false,
-      name: "x",
-    })
-  })
-
-  test("should reject multiple keybinds", () => {
-    expect(() => Keybind.parseOne("ctrl+x,ctrl+y")).toThrow("Expected exactly one keybind")
-  })
-})
-
-describe("Keybind.fromParsedKey", () => {
-  test("should preserve baseCode from ParsedKey", () => {
-    const result = Keybind.fromParsedKey({
-      name: "ㅊ",
-      ctrl: true,
-      meta: false,
-      shift: false,
-      option: false,
-      number: false,
-      sequence: "ㅊ",
-      raw: "\x1b[12618::99;5u",
-      eventType: "press",
-      source: "kitty",
-      baseCode: 99,
-    })
-
-    expect(result).toEqual({
-      name: "ㅊ",
-      ctrl: true,
-      meta: false,
-      shift: false,
-      super: false,
-      leader: false,
-      baseCode: 99,
-    })
-  })
-
-  test("should ignore leader unless explicitly requested", () => {
-    const key = {
-      name: "ㅊ",
-      ctrl: true,
-      meta: false,
-      shift: false,
-      option: false,
-      number: false,
-      sequence: "ㅊ",
-      raw: "\x1b[12618::99;5u",
-      eventType: "press" as const,
-      source: "kitty" as const,
-      baseCode: 99,
-    }
-
-    expect(Keybind.matchParsedKey("ctrl+c", key)).toBe(true)
-    expect(Keybind.matchParsedKey("ctrl+x,ctrl+c", key)).toBe(true)
-    expect(Keybind.matchParsedKey("ctrl+x,ctrl+y", key)).toBe(false)
-    expect(Keybind.matchParsedKey("ctrl+c", key, true)).toBe(false)
-  })
-})