tulingcode 0.1.0

package/src/cli/cmd/tui/asset/TEN_VAD_LICENSE

@@ -0,0 +1,12 @@
+TenVAD WASM Binary — License Notice
+
+The files ten_vad.wasm and ten_vad_loader.js in this directory are
+derived from the TEN VAD project:
+
+  https://github.com/ten-framework/ten-vad
+
+Licensed under the Apache License, Version 2.0.
+Copyright © 2025 Agora
+
+See the full license at:
+  https://github.com/ten-framework/ten-vad/blob/main/LICENSE

package/src/cli/cmd/tui/asset/ten_vad_loader.js

@@ -0,0 +1,30 @@
+
+var createVADModule = (() => {
+  var _scriptDir = import.meta.url;
+  
+  return (
+function(createVADModule) {
+  createVADModule = createVADModule || {};
+
+
+var a;a||(a=typeof createVADModule !== 'undefined' ? createVADModule : {});var k,l;a.ready=new Promise(function(b,c){k=b;l=c});var p=Object.assign({},a),r="object"==typeof window,u="function"==typeof importScripts,v="",w;
+if(r||u)u?v=self.location.href:"undefined"!=typeof document&&document.currentScript&&(v=document.currentScript.src),_scriptDir&&(v=_scriptDir),0!==v.indexOf("blob:")?v=v.substr(0,v.replace(/[?#].*/,"").lastIndexOf("/")+1):v="",u&&(w=b=>{var c=new XMLHttpRequest;c.open("GET",b,!1);c.responseType="arraybuffer";c.send(null);return new Uint8Array(c.response)});var aa=a.print||console.log.bind(console),x=a.printErr||console.warn.bind(console);Object.assign(a,p);p=null;var y;a.wasmBinary&&(y=a.wasmBinary);
+var noExitRuntime=a.noExitRuntime||!0;"object"!=typeof WebAssembly&&z("no native wasm support detected");var A,B=!1,C="undefined"!=typeof TextDecoder?new TextDecoder("utf8"):void 0,D,E,F;function J(){var b=A.buffer;D=b;a.HEAP8=new Int8Array(b);a.HEAP16=new Int16Array(b);a.HEAP32=new Int32Array(b);a.HEAPU8=E=new Uint8Array(b);a.HEAPU16=new Uint16Array(b);a.HEAPU32=F=new Uint32Array(b);a.HEAPF32=new Float32Array(b);a.HEAPF64=new Float64Array(b)}var K=[],L=[],M=[];
+function ba(){var b=a.preRun.shift();K.unshift(b)}var N=0,O=null,P=null;function z(b){if(a.onAbort)a.onAbort(b);b="Aborted("+b+")";x(b);B=!0;b=new WebAssembly.RuntimeError(b+". Build with -sASSERTIONS for more info.");l(b);throw b;}function Q(){return R.startsWith("data:application/octet-stream;base64,")}var R;if(a.locateFile){if(R="ten_vad.wasm",!Q()){var S=R;R=a.locateFile?a.locateFile(S,v):v+S}}else R=(new URL("ten_vad.wasm",import.meta.url)).href;
+function T(){var b=R;try{if(b==R&&y)return new Uint8Array(y);if(w)return w(b);throw"both async and sync fetching of the wasm failed";}catch(c){z(c)}}function ca(){return y||!r&&!u||"function"!=typeof fetch?Promise.resolve().then(function(){return T()}):fetch(R,{credentials:"same-origin"}).then(function(b){if(!b.ok)throw"failed to load wasm binary file at '"+R+"'";return b.arrayBuffer()}).catch(function(){return T()})}function U(b){for(;0<b.length;)b.shift()(a)}
+var da=[null,[],[]],ea={a:function(){z("")},f:function(b,c,m){E.copyWithin(b,c,c+m)},c:function(b){var c=E.length;b>>>=0;if(2147483648<b)return!1;for(var m=1;4>=m;m*=2){var h=c*(1+.2/m);h=Math.min(h,b+100663296);var d=Math;h=Math.max(b,h);d=d.min.call(d,2147483648,h+(65536-h%65536)%65536);a:{try{A.grow(d-D.byteLength+65535>>>16);J();var e=1;break a}catch(W){}e=void 0}if(e)return!0}return!1},e:function(){return 52},b:function(){return 70},d:function(b,c,m,h){for(var d=0,e=0;e<m;e++){var W=F[c>>2],
+X=F[c+4>>2];c+=8;for(var G=0;G<X;G++){var f=E[W+G],H=da[b];if(0===f||10===f){f=H;for(var n=0,q=n+NaN,t=n;f[t]&&!(t>=q);)++t;if(16<t-n&&f.buffer&&C)f=C.decode(f.subarray(n,t));else{for(q="";n<t;){var g=f[n++];if(g&128){var I=f[n++]&63;if(192==(g&224))q+=String.fromCharCode((g&31)<<6|I);else{var Y=f[n++]&63;g=224==(g&240)?(g&15)<<12|I<<6|Y:(g&7)<<18|I<<12|Y<<6|f[n++]&63;65536>g?q+=String.fromCharCode(g):(g-=65536,q+=String.fromCharCode(55296|g>>10,56320|g&1023))}}else q+=String.fromCharCode(g)}f=q}(1===
+b?aa:x)(f);H.length=0}else H.push(f)}d+=X}F[h>>2]=d;return 0}};
+(function(){function b(d){a.asm=d.exports;A=a.asm.g;J();L.unshift(a.asm.h);N--;a.monitorRunDependencies&&a.monitorRunDependencies(N);0==N&&(null!==O&&(clearInterval(O),O=null),P&&(d=P,P=null,d()))}function c(d){b(d.instance)}function m(d){return ca().then(function(e){return WebAssembly.instantiate(e,h)}).then(function(e){return e}).then(d,function(e){x("failed to asynchronously prepare wasm: "+e);z(e)})}var h={a:ea};N++;a.monitorRunDependencies&&a.monitorRunDependencies(N);if(a.instantiateWasm)try{return a.instantiateWasm(h,
+b)}catch(d){x("Module.instantiateWasm callback failed with error: "+d),l(d)}(function(){return y||"function"!=typeof WebAssembly.instantiateStreaming||Q()||"function"!=typeof fetch?m(c):fetch(R,{credentials:"same-origin"}).then(function(d){return WebAssembly.instantiateStreaming(d,h).then(c,function(e){x("wasm streaming compile failed: "+e);x("falling back to ArrayBuffer instantiation");return m(c)})})})().catch(l);return{}})();
+a.___wasm_call_ctors=function(){return(a.___wasm_call_ctors=a.asm.h).apply(null,arguments)};a._malloc=function(){return(a._malloc=a.asm.i).apply(null,arguments)};a._free=function(){return(a._free=a.asm.j).apply(null,arguments)};a._ten_vad_create=function(){return(a._ten_vad_create=a.asm.k).apply(null,arguments)};a._ten_vad_process=function(){return(a._ten_vad_process=a.asm.l).apply(null,arguments)};a._ten_vad_destroy=function(){return(a._ten_vad_destroy=a.asm.m).apply(null,arguments)};
+a._ten_vad_get_version=function(){return(a._ten_vad_get_version=a.asm.n).apply(null,arguments)};var V;P=function fa(){V||Z();V||(P=fa)};
+function Z(){function b(){if(!V&&(V=!0,a.calledRun=!0,!B)){U(L);k(a);if(a.onRuntimeInitialized)a.onRuntimeInitialized();if(a.postRun)for("function"==typeof a.postRun&&(a.postRun=[a.postRun]);a.postRun.length;){var c=a.postRun.shift();M.unshift(c)}U(M)}}if(!(0<N)){if(a.preRun)for("function"==typeof a.preRun&&(a.preRun=[a.preRun]);a.preRun.length;)ba();U(K);0<N||(a.setStatus?(a.setStatus("Running..."),setTimeout(function(){setTimeout(function(){a.setStatus("")},1);b()},1)):b())}}
+if(a.preInit)for("function"==typeof a.preInit&&(a.preInit=[a.preInit]);0<a.preInit.length;)a.preInit.pop()();Z();
+
+
+  return createVADModule.ready
+}
+);
+})();
+export default createVADModule;

package/src/cli/cmd/tui/attach.ts

@@ -0,0 +1,83 @@
+import { cmd } from "../cmd"
+import { UI } from "@/cli/ui"
+import { tui } from "./app"
+import { win32DisableProcessedInput, win32InstallCtrlCGuard } from "./win32"
+import { TuiConfig } from "@/cli/cmd/tui/config/tui"
+
+export const AttachCommand = cmd({
+  command: "attach <url>",
+  describe: "attach to a running tulingcode server",
+  builder: (yargs) =>
+    yargs
+      .positional("url", {
+        type: "string",
+        describe: "http://localhost:4096",
+        demandOption: true,
+      })
+      .option("dir", {
+        type: "string",
+        description: "directory to run in",
+      })
+      .option("continue", {
+        alias: ["c"],
+        describe: "continue the last session",
+        type: "boolean",
+      })
+      .option("session", {
+        alias: ["s"],
+        type: "string",
+        describe: "session id to continue",
+      })
+      .option("fork", {
+        type: "boolean",
+        describe: "fork the session when continuing (use with --continue or --session)",
+      })
+      .option("password", {
+        alias: ["p"],
+        type: "string",
+        describe: "basic auth password (defaults to tulingcode_SERVER_PASSWORD)",
+      }),
+  handler: async (args) => {
+    const unguard = win32InstallCtrlCGuard()
+    try {
+      win32DisableProcessedInput()
+
+      if (args.fork && !args.continue && !args.session) {
+        UI.error("--fork requires --continue or --session")
+        process.exitCode = 1
+        return
+      }
+
+      const directory = (() => {
+        if (!args.dir) return undefined
+        try {
+          process.chdir(args.dir)
+          return process.cwd()
+        } catch {
+          // If the directory doesn't exist locally (remote attach), pass it through.
+          return args.dir
+        }
+      })()
+      const headers = (() => {
+        const password = args.password ?? process.env.tulingcode_SERVER_PASSWORD
+        if (!password) return undefined
+        const auth = `Basic ${Buffer.from(`opencode:${password}`).toString("base64")}`
+        return { Authorization: auth }
+      })()
+      const config = await TuiConfig.get()
+      await tui({
+        url: args.url,
+        config,
+        args: {
+          continue: args.continue,
+          sessionID: args.session,
+          fork: args.fork,
+        },
+        directory,
+        headers,
+      })
+    } finally {
+      unguard?.()
+    }
+  },
+})

package/src/cli/cmd/tui/component/background-image.tsx

@@ -0,0 +1,150 @@
+import { createEffect, createMemo, createResource, onCleanup, Show } from "solid-js"
+import { useTerminalDimensions } from "@opentui/solid"
+import { RGBA, StyledText, type TextChunk, type TextRenderable } from "@opentui/core"
+import { tint, useTheme } from "@tui/context/theme"
+import { StarryBackground } from "./starry-background"
+import { PNG } from "pngjs"
+import jpeg from "jpeg-js"
+import path from "path"
+import { allocImageId, detectImageProtocol, kittyClear, kittyDisplay } from "../util/image-protocol"
+
+const HALF_BLOCK = "▀"
+const PROTOCOL = detectImageProtocol()
+const IMAGE_ALPHA = 0.45
+
+type Pixels = {
+  data: Uint8Array | Buffer
+  width: number
+  height: number
+}
+
+async function decode(filePath: string): Promise<Pixels | undefined> {
+  const file = Bun.file(filePath)
+  if (!(await file.exists())) return undefined
+  const buf = Buffer.from(await file.arrayBuffer())
+  const ext = path.extname(filePath).toLowerCase()
+  if (ext === ".png") {
+    const png = PNG.sync.read(buf)
+    return { data: png.data, width: png.width, height: png.height }
+  }
+  if (ext === ".jpg" || ext === ".jpeg") {
+    const decoded = jpeg.decode(buf, { useTArray: true })
+    return { data: decoded.data, width: decoded.width, height: decoded.height }
+  }
+  return undefined
+}
+
+function sample(p: Pixels, sx: number, sy: number) {
+  const x = Math.min(p.width - 1, Math.max(0, Math.floor(sx)))
+  const y = Math.min(p.height - 1, Math.max(0, Math.floor(sy)))
+  const i = (y * p.width + x) * 4
+  return {
+    r: p.data[i] ?? 0,
+    g: p.data[i + 1] ?? 0,
+    b: p.data[i + 2] ?? 0,
+    a: p.data[i + 3] ?? 255,
+  }
+}
+
+function pixelChunk(fg: RGBA, bg: RGBA): TextChunk {
+  return { __isChunk: true, text: HALF_BLOCK, fg, bg, attributes: 0 }
+}
+
+function StyledBackgroundText(props: { content: () => StyledText | undefined }) {
+  let text: TextRenderable | undefined
+
+  createEffect(() => {
+    const content = props.content()
+    if (!text || !content) return
+    text.content = content
+  })
+
+  return (
+    <text
+      ref={(item: TextRenderable) => {
+        text = item
+        const content = props.content()
+        if (content) item.content = content
+      }}
+      width="100%"
+      height="100%"
+      wrapMode="none"
+      selectable={false}
+    />
+  )
+}
+
+export function BackgroundImage(props: { path: string }) {
+  const kitty = createMemo(() => PROTOCOL === "kitty" && path.extname(props.path).toLowerCase() === ".png")
+  return (
+    <Show when={kitty()} fallback={<BackgroundImageHalfBlock path={props.path} />}>
+      <BackgroundImageKitty path={props.path} />
+    </Show>
+  )
+}
+
+function BackgroundImageKitty(props: { path: string }) {
+  const dimensions = useTerminalDimensions()
+  const id = allocImageId()
+  createEffect(() => {
+    const W = dimensions().width
+    const H = dimensions().height
+    const p = props.path
+    if (!W || !H || !p) return
+    kittyClear(id)
+    void kittyDisplay({ id, filePath: p, cols: W, rows: H }).catch(() => {})
+  })
+  onCleanup(() => kittyClear(id))
+  return null
+}
+
+function BackgroundImageHalfBlock(props: { path: string }) {
+  const dimensions = useTerminalDimensions()
+  const { theme } = useTheme()
+  const [pixels] = createResource(
+    () => props.path,
+    (p) => decode(p).catch(() => undefined),
+  )
+
+  const content = createMemo(() => {
+    const p = pixels()
+    const W = dimensions().width
+    const H = dimensions().height
+    if (!p || !W || !H) return undefined
+
+    // "cover" fit: scale image to fully fill the screen, cropping excess.
+    // Half-block doubles vertical resolution: each terminal row = 2 image rows.
+    const targetW = W
+    const targetH = H * 2
+    const ratio = Math.max(targetW / p.width, targetH / p.height)
+    const offsetX = (p.width * ratio - targetW) / 2
+    const offsetY = (p.height * ratio - targetH) / 2
+    const bg = theme.background
+    const chunks: TextChunk[] = []
+
+    Array.from({ length: H }).forEach((_, y) => {
+      Array.from({ length: W }).forEach((_, x) => {
+        const sx = (x + offsetX) / ratio
+        const top = sample(p, sx, (y * 2 + offsetY) / ratio)
+        const bot = sample(p, sx, (y * 2 + 1 + offsetY) / ratio)
+        chunks.push(
+          pixelChunk(
+            top.a < 16 ? bg : tint(bg, RGBA.fromInts(top.r, top.g, top.b), IMAGE_ALPHA),
+            bot.a < 16 ? bg : tint(bg, RGBA.fromInts(bot.r, bot.g, bot.b), IMAGE_ALPHA),
+          ),
+        )
+      })
+      if (y < H - 1) chunks.push({ __isChunk: true, text: "\n", attributes: 0 })
+    })
+
+    return new StyledText(chunks)
+  })
+
+  return (
+    <Show when={content()} fallback={<StarryBackground />}>
+      <box position="absolute" top={0} left={0} width="100%" height="100%" zIndex={0}>
+        <StyledBackgroundText content={content} />
+      </box>
+    </Show>
+  )
+}

package/src/cli/cmd/tui/component/bg-pulse.tsx

@@ -0,0 +1,130 @@
+import { BoxRenderable, RGBA } from "@opentui/core"
+import { createMemo, createSignal, For, onCleanup, onMount } from "solid-js"
+import { tint, useTheme } from "@tui/context/theme"
+
+const PERIOD = 4600
+const RINGS = 3
+const WIDTH = 3.8
+const TAIL = 9.5
+const AMP = 0.55
+const TAIL_AMP = 0.16
+const BREATH_AMP = 0.05
+const BREATH_SPEED = 0.0008
+// Offset so bg ring emits from GO center at the moment the logo pulse peaks.
+const PHASE_OFFSET = 0.29
+
+export type BgPulseMask = {
+  x: number
+  y: number
+  width: number
+  height: number
+  pad?: number
+  strength?: number
+}
+
+export function BgPulse(props: { centerX?: number; centerY?: number; masks?: BgPulseMask[] }) {
+  const { theme } = useTheme()
+  const [now, setNow] = createSignal(performance.now())
+  const [size, setSize] = createSignal<{ width: number; height: number }>({ width: 0, height: 0 })
+  let box: BoxRenderable | undefined
+
+  const timer = setInterval(() => setNow(performance.now()), 50)
+  onCleanup(() => clearInterval(timer))
+
+  const sync = () => {
+    if (!box) return
+    setSize({ width: box.width, height: box.height })
+  }
+
+  onMount(() => {
+    sync()
+    box?.on("resize", sync)
+  })
+
+  onCleanup(() => {
+    box?.off("resize", sync)
+  })
+
+  const grid = createMemo(() => {
+    const t = now()
+    const w = size().width
+    const h = size().height
+    if (w === 0 || h === 0) return [] as RGBA[][]
+    const cxv = props.centerX ?? w / 2
+    const cyv = props.centerY ?? h / 2
+    const reach = Math.hypot(Math.max(cxv, w - cxv), Math.max(cyv, h - cyv) * 2) + TAIL
+    const ringStates = Array.from({ length: RINGS }, (_, i) => {
+      const offset = i / RINGS
+      const phase = (t / PERIOD + offset - PHASE_OFFSET + 1) % 1
+      const envelope = Math.sin(phase * Math.PI)
+      const eased = envelope * envelope * (3 - 2 * envelope)
+      return {
+        head: phase * reach,
+        eased,
+      }
+    })
+    const normalizedMasks = props.masks?.map((m) => {
+      const pad = m.pad ?? 2
+      return {
+        left: m.x - pad,
+        right: m.x + m.width + pad,
+        top: m.y - pad,
+        bottom: m.y + m.height + pad,
+        pad,
+        strength: m.strength ?? 0.85,
+      }
+    })
+    const rows = [] as RGBA[][]
+    for (let y = 0; y < h; y++) {
+      const row = [] as RGBA[]
+      for (let x = 0; x < w; x++) {
+        const dx = x + 0.5 - cxv
+        const dy = (y + 0.5 - cyv) * 2
+        const dist = Math.hypot(dx, dy)
+        let level = 0
+        for (const ring of ringStates) {
+          const delta = dist - ring.head
+          const crest = Math.abs(delta) < WIDTH ? 0.5 + 0.5 * Math.cos((delta / WIDTH) * Math.PI) : 0
+          const tail = delta < 0 && delta > -TAIL ? (1 + delta / TAIL) ** 2.3 : 0
+          level += (crest * AMP + tail * TAIL_AMP) * ring.eased
+        }
+        const edgeFalloff = Math.max(0, 1 - (dist / (reach * 0.85)) ** 2)
+        const breath = (0.5 + 0.5 * Math.sin(t * BREATH_SPEED)) * BREATH_AMP
+        let maskAtten = 1
+        if (normalizedMasks) {
+          for (const m of normalizedMasks) {
+            if (x < m.left || x > m.right || y < m.top || y > m.bottom) continue
+            const inX = Math.min(x - m.left, m.right - x)
+            const inY = Math.min(y - m.top, m.bottom - y)
+            const edge = Math.min(inX / m.pad, inY / m.pad, 1)
+            const eased = edge * edge * (3 - 2 * edge)
+            const reduce = 1 - m.strength * eased
+            if (reduce < maskAtten) maskAtten = reduce
+          }
+        }
+        const strength = Math.min(1, ((level / RINGS) * edgeFalloff + breath * edgeFalloff) * maskAtten)
+        row.push(tint(theme.backgroundPanel, theme.primary, strength * 0.7))
+      }
+      rows.push(row)
+    }
+    return rows
+  })
+
+  return (
+    <box ref={(item: BoxRenderable) => (box = item)} width="100%" height="100%">
+      <For each={grid()}>
+        {(row) => (
+          <box flexDirection="row">
+            <For each={row}>
+              {(color) => (
+                <text bg={color} fg={color} selectable={false}>
+                  {" "}
+                </text>
+              )}
+            </For>
+          </box>
+        )}
+      </For>
+    </box>
+  )
+}

package/src/cli/cmd/tui/component/border.tsx

@@ -0,0 +1,21 @@
+export const EmptyBorder = {
+  topLeft: "",
+  bottomLeft: "",
+  vertical: "",
+  topRight: "",
+  bottomRight: "",
+  horizontal: " ",
+  bottomT: "",
+  topT: "",
+  cross: "",
+  leftT: "",
+  rightT: "",
+}
+
+export const SplitBorder = {
+  border: ["left" as const, "right" as const],
+  customBorderChars: {
+    ...EmptyBorder,
+    vertical: "┃",
+  },
+}

package/src/cli/cmd/tui/component/dialog-agent.tsx

@@ -0,0 +1,31 @@
+import { createMemo } from "solid-js"
+import { useLocal } from "@tui/context/local"
+import { DialogSelect } from "@tui/ui/dialog-select"
+import { useDialog } from "@tui/ui/dialog"
+
+export function DialogAgent() {
+  const local = useLocal()
+  const dialog = useDialog()
+
+  const options = createMemo(() =>
+    local.agent.list().map((item) => {
+      return {
+        value: item.name,
+        title: item.name,
+        description: item.native ? "native" : item.description,
+      }
+    }),
+  )
+
+  return (
+    <DialogSelect
+      title="Select agent"
+      current={local.agent.current()?.name}
+      options={options()}
+      onSelect={(option) => {
+        local.agent.set(option.value)
+        dialog.clear()
+      }}
+    />
+  )
+}

package/src/cli/cmd/tui/component/dialog-command.tsx

@@ -0,0 +1,208 @@
+import { useDialog } from "@tui/ui/dialog"
+import { DialogSelect, type DialogSelectOption, type DialogSelectRef } from "@tui/ui/dialog-select"
+import { isEditBufferRenderable } from "@opentui/core"
+import {
+  createContext,
+  createMemo,
+  createSignal,
+  getOwner,
+  onCleanup,
+  runWithOwner,
+  useContext,
+  type Accessor,
+  type ParentProps,
+} from "solid-js"
+import { useKeyboard, useRenderer } from "@opentui/solid"
+import { useKeybind } from "@tui/context/keybind"
+import { useLanguage } from "@tui/context/language"
+
+const CATEGORY_KEYS: Record<string, string> = {
+  session: "tui.command.category.session",
+  agent: "tui.command.category.agent",
+  provider: "tui.command.category.provider",
+  system: "tui.command.category.system",
+  prompt: "tui.command.category.prompt",
+  internal: "tui.command.category.internal",
+  external: "tui.command.category.external",
+}
+
+type Context = ReturnType<typeof init>
+const ctx = createContext<Context>()
+
+export type Slash = {
+  name: string
+  aliases?: string[]
+}
+
+export type CommandOption = DialogSelectOption<string> & {
+  keybind?: string
+  suggested?: boolean
+  slash?: Slash
+  hidden?: boolean
+  enabled?: boolean
+}
+
+function init() {
+  const root = getOwner()
+  const [registrations, setRegistrations] = createSignal<Accessor<CommandOption[]>[]>([])
+  const [suspendCount, setSuspendCount] = createSignal(0)
+  const dialog = useDialog()
+  const keybind = useKeybind()
+  const lang = useLanguage()
+  const renderer = useRenderer()
+
+  const localizeCategory = (category: string | undefined) => {
+    if (!category) return category
+    const key = CATEGORY_KEYS[category]
+    if (key) return lang.t(key)
+    return category
+  }
+
+  const entries = createMemo(() => {
+    const all = registrations().flatMap((x) => x())
+    return all.map((x) => ({
+      ...x,
+      category: localizeCategory(x.category),
+      footer: x.keybind ? keybind.print(x.keybind) : undefined,
+    }))
+  })
+
+  const isEnabled = (option: CommandOption) => option.enabled !== false
+  const isVisible = (option: CommandOption) => isEnabled(option) && !option.hidden
+
+  const visibleOptions = createMemo(() => entries().filter((option) => isVisible(option)))
+  const suggestedOptions = createMemo(() =>
+    visibleOptions()
+      .filter((option) => option.suggested)
+      .map((option) => ({
+        ...option,
+        value: `suggested:${option.value}`,
+        category: lang.t("tui.command.palette.suggested"),
+      })),
+  )
+  const suspended = () => suspendCount() > 0
+  const isTextEditingKey = (evt: Parameters<typeof keybind.match>[1]) =>
+    Object.keys(keybind.all).some(
+      (name) =>
+        (name.startsWith("input_") || name === "history_previous" || name === "history_next") &&
+        keybind.match(name, evt),
+    )
+
+  useKeyboard((evt) => {
+    if (suspended()) return
+    if (dialog.stack.length > 0) return
+    if (evt.defaultPrevented) return
+    const textInputFocused = isEditBufferRenderable(renderer.currentFocusedRenderable)
+    const textEditingKey = textInputFocused && isTextEditingKey(evt)
+    for (const option of entries()) {
+      if (!isEnabled(option)) continue
+      if (textEditingKey && !option.keybind?.startsWith("input_")) continue
+      if (option.keybind && keybind.match(option.keybind, evt)) {
+        evt.preventDefault()
+        option.onSelect?.(dialog)
+        return
+      }
+    }
+  })
+
+  const result = {
+    trigger(name: string) {
+      for (const option of entries()) {
+        if (option.value === name) {
+          if (!isEnabled(option)) return
+          option.onSelect?.(dialog)
+          return
+        }
+      }
+    },
+    slashes() {
+      return visibleOptions().flatMap((option) => {
+        const slash = option.slash
+        if (!slash) return []
+        const description = option.description ?? option.title
+        const onSelect = () => result.trigger(option.value)
+        return [
+          { display: "/" + slash.name, description, onSelect },
+          ...(slash.aliases ?? []).map((alias) => ({
+            display: "/" + alias,
+            description,
+            onSelect,
+          })),
+        ]
+      })
+    },
+    keybinds(enabled: boolean) {
+      setSuspendCount((count) => count + (enabled ? -1 : 1))
+    },
+    suspended,
+    show() {
+      dialog.replace(() => <DialogCommand options={visibleOptions()} suggestedOptions={suggestedOptions()} />)
+    },
+    register(cb: () => CommandOption[]) {
+      const owner = getOwner() ?? root
+      if (!owner) return () => {}
+
+      let list: Accessor<CommandOption[]> | undefined
+
+      // TUI plugins now register commands via an async store that runs outside an active reactive scope.
+      // runWithOwner attaches createMemo/onCleanup to this owner so plugin registrations stay reactive and dispose correctly.
+      runWithOwner(owner, () => {
+        list = createMemo(cb)
+        const ref = list
+        if (!ref) return
+        setRegistrations((arr) => [ref, ...arr])
+        onCleanup(() => {
+          setRegistrations((arr) => arr.filter((x) => x !== ref))
+        })
+      })
+
+      if (!list) return () => {}
+      let done = false
+      return () => {
+        if (done) return
+        done = true
+        const ref = list
+        if (!ref) return
+        setRegistrations((arr) => arr.filter((x) => x !== ref))
+      }
+    },
+  }
+  return result
+}
+
+export function useCommandDialog() {
+  const value = useContext(ctx)
+  if (!value) {
+    throw new Error("useCommandDialog must be used within a CommandProvider")
+  }
+  return value
+}
+
+export function CommandProvider(props: ParentProps) {
+  const value = init()
+  const dialog = useDialog()
+  const keybind = useKeybind()
+
+  useKeyboard((evt) => {
+    if (value.suspended()) return
+    if (dialog.stack.length > 0) return
+    if (evt.defaultPrevented) return
+    if (keybind.match("command_list", evt)) {
+      evt.preventDefault()
+      value.show()
+      return
+    }
+  })
+
+  return <ctx.Provider value={value}>{props.children}</ctx.Provider>
+}
+
+function DialogCommand(props: { options: CommandOption[]; suggestedOptions: CommandOption[] }) {
+  const lang = useLanguage()
+  let ref: DialogSelectRef<string>
+  const list = () => {
+    if (ref?.filter) return props.options
+    return [...props.suggestedOptions, ...props.options]
+  }
+  return <DialogSelect ref={(r) => (ref = r)} title={lang.t("tui.command.palette.title")} options={list()} />
+}