my-opencode-toolkit 0.0.0-stage → 0.2.2

package/src/shared/settings.ts

@@ -0,0 +1,133 @@
+import { asRecord } from "./json.ts"
+
+/** 界面语言；`auto` 跟随系统。 */
+export type Lang = "auto" | "zh" | "en"
+
+/** 系统通知开关。 */
+export type NotificationSettings = {
+  /** 总开关，关掉后其余字段都不生效。 */
+  readonly enabled: boolean
+  /** 会话完成（空闲）时通知。 */
+  readonly onComplete: boolean
+  /** 代理提问时通知。 */
+  readonly onQuestion: boolean
+  /** 请求权限时通知。 */
+  readonly onPermission: boolean
+  /** 只通知主会话，忽略子代理。 */
+  readonly onlyMainSession: boolean
+}
+
+/** 持久目标开关。 */
+export type GoalSettings = {
+  readonly enabled: boolean
+}
+
+/** 定时任务开关。 */
+export type SchedulingSettings = {
+  readonly enabled: boolean
+}
+
+/** TUI 侧栏显示项。 */
+export type SidebarSettings = {
+  readonly enabled: boolean
+  readonly showCache: boolean
+  readonly showTools: boolean
+  readonly showSubagents: boolean
+  readonly collapsed: boolean
+}
+
+/** 插件全部设置。 */
+export type Settings = {
+  readonly lang: Lang
+  /** 插件总开关；关掉后不注册工具、不注入、不通知。 */
+  readonly enabled: boolean
+  readonly notification: NotificationSettings
+  readonly goal: GoalSettings
+  readonly scheduling: SchedulingSettings
+  readonly sidebar: SidebarSettings
+}
+
+/**
+ * 默认设置。
+ *
+ * 预期：通知默认开、Goal 默认开、定时默认开、侧栏默认开；
+ *       语言跟随系统；侧栏默认展开。
+ */
+export const DEFAULT_SETTINGS: Settings = {
+  lang: "auto",
+  enabled: true,
+  notification: {
+    enabled: true,
+    onComplete: true,
+    onQuestion: true,
+    onPermission: true,
+    onlyMainSession: true,
+  },
+  goal: { enabled: true },
+  scheduling: { enabled: true },
+  sidebar: {
+    enabled: true,
+    showCache: true,
+    showTools: true,
+    showSubagents: true,
+    collapsed: false,
+  },
+}
+
+/**
+ * 输入：任意值（通常来自存储或插件 options）。
+ * 输出：字段完整、类型合法的设置。
+ * 预期：缺失或类型错误的字段回退到默认值；未知字段被丢弃；不抛异常。
+ */
+export function normalizeSettings(raw: unknown): Settings {
+  const record = asRecord(raw) ?? {}
+  const notification = asRecord(record["notification"]) ?? {}
+  const goal = asRecord(record["goal"]) ?? {}
+  const scheduling = asRecord(record["scheduling"]) ?? {}
+  const sidebar = asRecord(record["sidebar"]) ?? {}
+
+  return {
+    lang: readLang(record["lang"], DEFAULT_SETTINGS.lang),
+    enabled: readBoolean(record["enabled"], DEFAULT_SETTINGS.enabled),
+    notification: {
+      enabled: readBoolean(notification["enabled"], DEFAULT_SETTINGS.notification.enabled),
+      onComplete: readBoolean(notification["onComplete"], DEFAULT_SETTINGS.notification.onComplete),
+      onQuestion: readBoolean(notification["onQuestion"], DEFAULT_SETTINGS.notification.onQuestion),
+      onPermission: readBoolean(notification["onPermission"], DEFAULT_SETTINGS.notification.onPermission),
+      onlyMainSession: readBoolean(
+        notification["onlyMainSession"],
+        DEFAULT_SETTINGS.notification.onlyMainSession,
+      ),
+    },
+    goal: {
+      enabled: readBoolean(goal["enabled"], DEFAULT_SETTINGS.goal.enabled),
+    },
+    scheduling: {
+      enabled: readBoolean(scheduling["enabled"], DEFAULT_SETTINGS.scheduling.enabled),
+    },
+    sidebar: {
+      enabled: readBoolean(sidebar["enabled"], DEFAULT_SETTINGS.sidebar.enabled),
+      showCache: readBoolean(sidebar["showCache"], DEFAULT_SETTINGS.sidebar.showCache),
+      showTools: readBoolean(sidebar["showTools"], DEFAULT_SETTINGS.sidebar.showTools),
+      showSubagents: readBoolean(sidebar["showSubagents"], DEFAULT_SETTINGS.sidebar.showSubagents),
+      collapsed: readBoolean(sidebar["collapsed"], DEFAULT_SETTINGS.sidebar.collapsed),
+    },
+  }
+}
+
+/**
+ * 输入：任意值 + 默认值。
+ * 输出：布尔值，非布尔时用默认值。
+ * 预期：不做字符串/数字到布尔的隐式转换。
+ */
+function readBoolean(value: unknown, fallback: boolean): boolean {
+  return typeof value === "boolean" ? value : fallback
+}
+
+/**
+ * 输入：任意值 + 默认语言。
+ * 输出：合法语言枚举，其余回退默认值。
+ */
+function readLang(value: unknown, fallback: Lang): Lang {
+  return value === "auto" || value === "zh" || value === "en" ? value : fallback
+}

package/src/shared/types.ts

@@ -0,0 +1,4 @@
+/** 可注销句柄。 */
+export type Disposable = {
+  dispose(): Promise<void>
+}

package/src/stats.ts

@@ -0,0 +1,215 @@
+import type { Plugin } from "@opencode/plugin"
+
+import { asRecord } from "./shared/json.ts"
+
+/** 单个会话的进程内统计。 */
+export type SessionStats = {
+  readonly steps: number
+  readonly input: number
+  readonly output: number
+  readonly cached: number
+  readonly tools: Readonly<Record<string, number>>
+  readonly subagents: number
+}
+
+/** 统计累加器。 */
+export type StatsTracker = {
+  /** 输入：会话 + 本步 token；输出：无。预期：input/output/缓存分别累加。 */
+  recordStep(sessionID: string, tokens: unknown): void
+  /** 输入：会话 + 工具名；输出：无。预期：按工具名计数。 */
+  recordTool(sessionID: string, tool: string): void
+  /** 输入：父会话；输出：无。预期：子代理数量 +1。 */
+  recordSubagent(parentID: string): void
+  /** 输入：会话；输出：统计快照。 */
+  get(sessionID: string): SessionStats
+  /** 输入：会话；输出：是否已从 OpenCode 消息重建过。 */
+  isSeeded(sessionID: string): boolean
+  /** 输入：会话 + 重建结果；输出：无。预期：覆盖当前值并标记已 seed。 */
+  seed(sessionID: string, stats: SessionStats): void
+  /** 输入：会话；输出：无。预期：删除该会话统计。 */
+  forget(sessionID: string): void
+  /** 输入：无；输出：无。预期：清空全部统计。 */
+  clear(): void
+}
+
+type MutableStats = {
+  steps: number
+  input: number
+  output: number
+  cached: number
+  tools: Record<string, number>
+  subagents: number
+  seeded: boolean
+}
+
+/**
+ * 输入：无。
+ * 输出：内存统计累加器。
+ * 预期：只统计当前进程生命周期；重启后从 0 开始。
+ */
+export function createStatsTracker(): StatsTracker {
+  const sessions = new Map<string, MutableStats>()
+
+  /** 输入：会话；输出：可写统计。预期：不存在时创建空统计。 */
+  const of = (sessionID: string): MutableStats => {
+    const existing = sessions.get(sessionID)
+    if (existing !== undefined) return existing
+    const created: MutableStats = { steps: 0, input: 0, output: 0, cached: 0, tools: {}, subagents: 0, seeded: false }
+    sessions.set(sessionID, created)
+    return created
+  }
+
+  /** 输入：任意值；输出：非负有限数，否则 0。 */
+  const count = (value: unknown): number =>
+    typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0
+
+  return {
+    recordStep(sessionID, tokens) {
+      const record = asRecord(tokens)
+      if (record === undefined) return
+      const cache = asRecord(record["cache"]) ?? {}
+      const stats = of(sessionID)
+      stats.steps += 1
+      stats.input += count(record["input"])
+      stats.output += count(record["output"])
+      stats.cached += count(cache["read"]) + count(cache["write"])
+    },
+
+    recordTool(sessionID, tool) {
+      if (tool.length === 0) return
+      const stats = of(sessionID)
+      stats.tools[tool] = (stats.tools[tool] ?? 0) + 1
+    },
+
+    recordSubagent(parentID) {
+      if (parentID.length === 0) return
+      of(parentID).subagents += 1
+    },
+
+    get(sessionID) {
+      const stats = sessions.get(sessionID)
+      if (stats === undefined) {
+        return { steps: 0, input: 0, output: 0, cached: 0, tools: {}, subagents: 0 }
+      }
+      return {
+        steps: stats.steps,
+        input: stats.input,
+        output: stats.output,
+        cached: stats.cached,
+        tools: { ...stats.tools },
+        subagents: stats.subagents,
+      }
+    },
+
+    isSeeded(sessionID) {
+      return sessions.get(sessionID)?.seeded ?? false
+    },
+
+    seed(sessionID, stats) {
+      sessions.set(sessionID, { ...stats, tools: { ...stats.tools }, seeded: true })
+    },
+
+    forget(sessionID) {
+      sessions.delete(sessionID)
+    },
+
+    clear() {
+      sessions.clear()
+    },
+  }
+}
+
+/**
+ * 输入：统计累加器 + 会话事件。
+ * 输出：无。
+ * 预期：step 结束记 token，会话删除清统计，新建子代理给父会话 +1。
+ */
+export function trackEvent(
+  tracker: StatsTracker,
+  event: { readonly type: string; readonly data: unknown },
+): void {
+  const data = asRecord(event.data)
+  if (data === undefined) return
+  const sessionID = data["sessionID"]
+  if (typeof sessionID !== "string" || sessionID.length === 0) return
+
+  if (event.type === "session.step.ended") {
+    tracker.recordStep(sessionID, data["tokens"])
+    return
+  }
+  if (event.type === "session.deleted") {
+    tracker.forget(sessionID)
+    return
+  }
+  if (event.type === "session.created") {
+    const parentID = data["parentID"]
+    if (typeof parentID === "string" && parentID.length > 0) tracker.recordSubagent(parentID)
+  }
+}
+
+/**
+ * 输入：插件上下文 + 父会话 ID。
+ * 输出：该会话的子代理数量。
+ * 预期：按 parentID 过滤并逐页翻完；任何一页读取失败就返回已统计的数量，不抛异常。
+ */
+async function countSubagents(ctx: Plugin.Context, sessionID: string): Promise<number> {
+  let cursor: string | undefined
+  let total = 0
+  // 翻页上限：防止异常服务端返回循环 cursor 时无限循环。
+  for (let page = 0; page < 200; page += 1) {
+    const listed = await ctx.session
+      .list({ parentID: sessionID, ...(cursor === undefined ? {} : { cursor }) })
+      .catch(() => undefined)
+    if (listed === undefined) return total
+    total += listed.data.length
+
+    const next = listed.cursor.next
+    if (next === undefined || next === null || next === cursor) return total
+    cursor = next
+  }
+  return total
+}
+
+/**
+ * 输入：插件上下文 + 会话 ID。
+ * 输出：从 OpenCode 已存消息重建的统计。
+ * 预期：只统计 assistant 消息的 tokens 与 tool 片段；子代理数来自会话列表的 parentID 过滤。
+ *       读取失败按空统计处理，不抛异常。
+ */
+export async function buildStats(ctx: Plugin.Context, sessionID: string): Promise<SessionStats> {
+  const messages = await ctx.session.context({ sessionID }).catch(() => [])
+  let steps = 0
+  let input = 0
+  let output = 0
+  let cached = 0
+  const tools: Record<string, number> = {}
+
+  for (const message of messages) {
+    if (message.type !== "assistant") continue
+    steps += 1
+    const tokens = message.tokens
+    if (tokens !== undefined) {
+      input += tokens.input
+      output += tokens.output
+      cached += tokens.cache.read + tokens.cache.write
+    }
+    for (const part of message.content) {
+      if (part.type !== "tool") continue
+      tools[part.name] = (tools[part.name] ?? 0) + 1
+    }
+  }
+
+  const subagents = await countSubagents(ctx, sessionID)
+  return { steps, input, output, cached, tools, subagents }
+}
+
+/**
+ * 输入：输入 token 与缓存 token。
+ * 输出：缓存命中率百分比，向下截断到两位小数。
+ * 预期：分母为 0 时返回 0；`100` 只代表真实全命中。
+ */
+export function hitRatePercent(input: number, cached: number): number {
+  const total = input + cached
+  if (total <= 0) return 0
+  return Math.floor((cached / total) * 10_000) / 100
+}

package/src/tools/ping.ts

@@ -0,0 +1,40 @@
+import type { Plugin } from "@opencode/plugin"
+import { Schema } from "effect"
+
+import { resolveMessages } from "../i18n/index.ts"
+import { loadSettings } from "../shared/settings-store.ts"
+
+const DESCRIPTION =
+  "Returns the my-opencode-toolkit status: whether the plugin is enabled and which language it uses. " +
+  "Use it to verify the plugin is loaded."
+
+const PingInput = Schema.Struct({})
+const PingOutput = Schema.Struct({
+  enabled: Schema.Boolean,
+  lang: Schema.String,
+})
+
+/**
+ * 输入：服务端插件上下文。
+ * 输出：注册 `toolkit_ping` 工具，返回注销句柄。
+ * 预期：只读——读取设置并按当前语言返回一行状态，不修改任何状态。
+ */
+export async function registerPingTool(ctx: Plugin.Context): Promise<{ dispose(): Promise<void> }> {
+  return ctx.tool.transform((tools) => {
+    tools.add({
+      name: "toolkit_ping",
+      options: { codemode: false },
+      description: DESCRIPTION,
+      input: PingInput,
+      output: PingOutput,
+      execute: async () => {
+        const settings = await loadSettings(ctx.storage)
+        const messages = resolveMessages(settings.lang === "auto" ? undefined : settings.lang)
+        return {
+          output: { enabled: settings.enabled, lang: settings.lang },
+          content: messages.tool.pingResult(settings.enabled, settings.lang),
+        }
+      },
+    })
+  })
+}

package/src/tui/index.tsx

@@ -0,0 +1,274 @@
+import { Plugin } from "@opencode/plugin/tui"
+import type { Context } from "@opencode/plugin/tui/context"
+import { createSignal, onCleanup, onMount } from "solid-js"
+
+import { resolveMessages, type Messages } from "../i18n/index.ts"
+import { formatTokens } from "../shared/format.ts"
+import { DEFAULT_SETTINGS, type Lang, type Settings } from "../shared/settings.ts"
+import { toolkitRpc, type PanelData } from "../shared/rpc.ts"
+
+/** 主菜单条目。 */
+type MenuChoice = "enabled" | "language" | "notifications" | "goal" | "scheduling" | "sidebar"
+
+/** 侧栏子菜单条目。 */
+type SidebarChoice = "enabled" | "showCache" | "showTools" | "showSubagents" | "collapsed"
+
+/** 输入：设置里的语言枚举；输出：`resolveMessages` 需要的 locale。 */
+function localeOf(lang: Lang): string | undefined {
+  return lang === "auto" ? undefined : lang
+}
+
+/**
+ * 输入：TUI 上下文、会话 ID、设置访问器、文案访问器。
+ * 输出：侧栏面板。
+ * 预期：挂载时拉一次数据，之后按会话事件节流刷新。
+ */
+export function Sidebar(props: {
+  readonly context: Context
+  readonly sessionID: string
+  readonly settings: () => Settings
+  readonly copy: () => Messages
+}) {
+  const rpc = toolkitRpc(props.context.client)
+  const [panel, setPanel] = createSignal<PanelData | null>(null)
+  let timer: ReturnType<typeof setTimeout> | undefined
+
+  /** 拉取面板数据；失败保留上一次结果。 */
+  const refresh = (): void => {
+    void rpc
+      .panelGet({ sessionID: props.sessionID })
+      .then((data) => {
+        setPanel(data)
+      })
+      .catch(() => undefined)
+  }
+
+  onMount(() => {
+    refresh()
+    const off = props.context.data.listen(({ details }) => {
+      if (
+        details.type !== "session.idle" &&
+        details.type !== "session.step.ended" &&
+        details.type !== "session.usage.updated"
+      ) {
+        return
+      }
+      if (timer !== undefined) clearTimeout(timer)
+      timer = setTimeout(refresh, 300)
+    })
+    onCleanup(() => {
+      off()
+      if (timer !== undefined) clearTimeout(timer)
+    })
+  })
+
+  /** 输入：状态字符串；输出：本地化状态名。 */
+  const statusLabel = (text: Messages, status: string): string => text.panel.status[status] ?? status
+
+  const goalLine = (): string => {
+    const text = props.copy()
+    const goal = panel()?.goal
+    if (goal === null || goal === undefined) return `${text.panel.goal}: ${text.panel.noGoal}`
+    const budget = goal.tokenBudget === undefined ? "" : ` / ${formatTokens(goal.tokenBudget)}`
+    return `${text.panel.goal}: ${goal.objective} · ${statusLabel(text, goal.status)} · ${formatTokens(goal.tokensUsed)}${budget}`
+  }
+
+  const cacheLine = (): string => {
+    const text = props.copy()
+    const stats = panel()?.stats
+    if (stats === undefined) return `${text.panel.cache}: --`
+    return `${text.panel.cache}: ${stats.hitRate.toFixed(2)}% · ${formatTokens(stats.input)} / ${formatTokens(stats.output)}`
+  }
+
+  const toolsLine = (): string => {
+    const text = props.copy()
+    const stats = panel()?.stats
+    if (stats === undefined || stats.tools.length === 0) return `${text.panel.tools}: --`
+    const top = stats.tools
+      .slice(0, 3)
+      .map((tool) => `${tool.name} ${String(tool.count)}`)
+      .join(" · ")
+    return `${text.panel.tools}: ${top}`
+  }
+
+  const subagentsLine = (): string => {
+    const text = props.copy()
+    return `${text.panel.subagents}: ${String(panel()?.stats.subagents ?? 0)}`
+  }
+
+  const scheduleLine = (): string => {
+    const text = props.copy()
+    const loops = panel()?.loops.length ?? 0
+    const jobs = panel()?.jobs.length ?? 0
+    return `${text.panel.loops}: ${String(loops)} · ${text.panel.jobs}: ${String(jobs)}`
+  }
+
+  return (
+    <box flexDirection="column">
+      <text>{props.copy().panel.title}</text>
+      {props.settings().sidebar.enabled && !props.settings().sidebar.collapsed ? (
+        <box flexDirection="column">
+          <text>{goalLine()}</text>
+          {props.settings().sidebar.showCache ? <text>{cacheLine()}</text> : null}
+          {props.settings().sidebar.showTools ? <text>{toolsLine()}</text> : null}
+          {props.settings().sidebar.showSubagents ? <text>{subagentsLine()}</text> : null}
+          <text>{scheduleLine()}</text>
+        </box>
+      ) : null}
+    </box>
+  )
+}
+
+/**
+ * 输入：TUI 插件上下文（含插件 options）。
+ * 输出：侧栏面板 + `/my-opencode-toolkit` 设置命令。
+ * 预期：设置以服务端存储为准，启动时通过 RPC 读取；写入失败时回滚本地值。
+ *       keymap 层在 setup 作用域注册，生命周期跟随插件，不依赖某个 slot 组件是否挂载。
+ */
+export default Plugin.define({
+  id: "my-opencode-toolkit.tui",
+
+  async setup(context) {
+    const rpc = toolkitRpc(context.client)
+    const initial = await rpc.settingsGet({}).catch((): Settings => DEFAULT_SETTINGS)
+    const [settings, setSettings] = createSignal<Settings>(initial)
+
+    /**
+     * 输入：新设置。
+     * 输出：无。
+     * 预期：先乐观更新界面，服务端确认后用返回值覆盖；失败则回滚。
+     */
+    const update = async (next: Settings): Promise<void> => {
+      const previous = settings()
+      setSettings(next)
+      try {
+        setSettings(await rpc.settingsSet(next))
+      } catch {
+        setSettings(previous)
+      }
+    }
+
+    const copy = (): Messages => resolveMessages(localeOf(settings().lang))
+
+    /** 选择语言并写回。 */
+    const chooseLanguage = async (): Promise<void> => {
+      const picked = await context.ui.dialog.select<Lang>({
+        title: copy().menu.language,
+        current: settings().lang,
+        options: [
+          { title: copy().menu.auto, value: "auto" },
+          { title: copy().menu.chinese, value: "zh" },
+          { title: copy().menu.english, value: "en" },
+        ],
+      })
+      if (picked === undefined) return
+      await update({ ...settings(), lang: picked })
+    }
+
+    /** 侧栏子菜单：逐项切换显示开关。 */
+    const chooseSidebar = async (): Promise<void> => {
+      for (;;) {
+        const current = settings()
+        const text = copy()
+        const onOff = (value: boolean): string => (value ? text.menu.on : text.menu.off)
+        const choice = await context.ui.dialog.select<SidebarChoice>({
+          title: text.menu.sidebar,
+          options: [
+            { title: text.menu.enabled, value: "enabled", footer: onOff(current.sidebar.enabled) },
+            { title: text.menu.showCache, value: "showCache", footer: onOff(current.sidebar.showCache) },
+            { title: text.menu.showTools, value: "showTools", footer: onOff(current.sidebar.showTools) },
+            { title: text.menu.showSubagents, value: "showSubagents", footer: onOff(current.sidebar.showSubagents) },
+            { title: text.menu.collapsed, value: "collapsed", footer: onOff(current.sidebar.collapsed) },
+          ],
+        })
+        if (choice === undefined) return
+        const next = { ...current.sidebar, [choice]: !current.sidebar[choice] }
+        await update({ ...current, sidebar: next })
+      }
+    }
+
+    /**
+     * 输入：要切换的条目。
+     * 输出：无。
+     * 预期：只改对应字段，其余设置保持不变。
+     */
+    const toggle = async (choice: Exclude<MenuChoice, "language" | "sidebar">): Promise<void> => {
+      const current = settings()
+      switch (choice) {
+        case "enabled":
+          await update({ ...current, enabled: !current.enabled })
+          return
+        case "notifications":
+          await update({
+            ...current,
+            notification: { ...current.notification, enabled: !current.notification.enabled },
+          })
+          return
+        case "goal":
+          await update({ ...current, goal: { enabled: !current.goal.enabled } })
+          return
+        case "scheduling":
+          await update({ ...current, scheduling: { enabled: !current.scheduling.enabled } })
+          return
+      }
+    }
+
+    /** 打开菜单；选择语言/侧栏进入子菜单，其余条目原地切换后重开。 */
+    const openMenu = async (): Promise<void> => {
+      for (;;) {
+        const current = settings()
+        const text = copy()
+        const onOff = (value: boolean): string => (value ? text.menu.on : text.menu.off)
+        const choice = await context.ui.dialog.select<MenuChoice>({
+          title: text.menu.title,
+          options: [
+            { title: text.menu.enabled, value: "enabled", footer: onOff(current.enabled) },
+            { title: text.menu.language, value: "language", footer: current.lang },
+            { title: text.menu.notifications, value: "notifications", footer: onOff(current.notification.enabled) },
+            { title: text.menu.goal, value: "goal", footer: onOff(current.goal.enabled) },
+            { title: text.menu.scheduling, value: "scheduling", footer: onOff(current.scheduling.enabled) },
+            { title: text.menu.sidebar, value: "sidebar", footer: onOff(current.sidebar.enabled) },
+          ],
+        })
+        if (choice === undefined) return
+        if (choice === "language") {
+          await chooseLanguage()
+          continue
+        }
+        if (choice === "sidebar") {
+          await chooseSidebar()
+          continue
+        }
+        await toggle(choice)
+      }
+    }
+
+    context.keymap.layer(() => ({
+      mode: "global",
+      commands: [
+        {
+          id: "my-opencode-toolkit.settings",
+          title: copy().command.title,
+          description: copy().command.description,
+          group: copy().command.group,
+          slash: { name: "my-opencode-toolkit" },
+          palette: true,
+          run() {
+            void openMenu()
+          },
+        },
+      ],
+    }))
+
+    const disposePanel = context.ui.slot({
+      append: "sidebar.content",
+      render: (input) => (
+        <Sidebar context={context} sessionID={input.sessionID} settings={settings} copy={copy} />
+      ),
+    })
+
+    return () => {
+      disposePanel()
+    }
+  },
+})

package/tui.ts

@@ -0,0 +1,3 @@
+// 本地插件目录入口：OpenCode 的 TUI 插件解析会找 <dir>/tui，
+// 这里只做转发，真正实现放在 src/tui/index.tsx。
+export { default } from "./src/tui/index.tsx"