@opencode-cockpit/shell 0.1.4 → 0.2.0

package/src/tui/index.tsx

@@ -1,286 +0,0 @@
-/** @jsxImportSource @opentui/solid */
-import {
-  createBindingLookup,
-  type TuiPlugin,
-  type TuiPluginApi,
-  type TuiPluginModule,
-} from "@opencode-ai/plugin/tui"
-import { claimFeature, duplicateFeatureMessage } from "@opencode-cockpit/client"
-import { createSignal } from "solid-js"
-import { createClient } from "../connect.ts"
-import { Console } from "./console.tsx"
-import { Dock } from "./dock.tsx"
-import { SidebarShells } from "./sidebar.tsx"
-import { createShellStore, type ShellStore } from "./store.ts"
-import { BADGE_LABEL, displayCommand, kindOf, order } from "./view.ts"
-
-const DEFAULT_KEYS = {
-  "cockpit.shells.dock": "<leader>o",
-  "cockpit.shells.console": "<leader>i",
-}
-
-export interface ShellTuiOptions {
-  dockHeight?: number
-  /** Failures stay visible this long after they end (default 30). */
-  historyMinutes?: number
-  dockOpen?: boolean
-  keybinds?: Record<string, string>
-}
-
-const SHELL_PACKAGE = "@opencode-cockpit/shell"
-
-/** Shell's TUI half as a factory, so bundles such as `opencode-cockpit` can include it. */
-export function createShellTui({ source = SHELL_PACKAGE }: { source?: string } = {}): TuiPlugin {
-  return async (api, rawOptions, meta) => {
-    // The renderer is shared by every TUI plugin in this OpenCode window.
-    const claim = claimFeature(api.renderer, "shell", source)
-    if (!claim.active) {
-      api.ui.toast({
-        variant: "warning",
-        title: "opencode-cockpit",
-        message: duplicateFeatureMessage("Shell", claim.owner, source),
-        duration: 10_000,
-      })
-      return
-    }
-    api.lifecycle.onDispose(() => claim.release())
-    await shellTui(api, rawOptions, meta)
-  }
-}
-
-const shellTui: TuiPlugin = async (api, rawOptions) => {
-  const options = (rawOptions ?? {}) as ShellTuiOptions
-  const client = createClient("opencode-cockpit/tui")
-  const store = createShellStore(api, client, { historyMinutes: options.historyMinutes })
-  const keys = createBindingLookup({ ...DEFAULT_KEYS, ...options.keybinds })
-
-  const [dockOpen, setDockOpen] = createSignal<boolean>(
-    api.kv.get("cockpit.dock.open", options.dockOpen ?? false),
-  )
-  const toggleDock = () => {
-    const next = !dockOpen()
-    setDockOpen(next)
-    api.kv.set("cockpit.dock.open", next)
-  }
-  const shortcut = (command: string) => {
-    const bindings = api.keymap.getCommandBindings({ visibility: "registered", commands: [command] })
-    return api.keys.formatBindings(bindings.get(command)) ?? ""
-  }
-
-  const openConsole = (id?: string, typing = false) => {
-    if (id) store.select(id)
-    api.ui.dialog.replace(
-      () => (
-        <Console
-          api={api}
-          store={store}
-          typing={typing}
-          onClose={() => api.ui.dialog.clear()}
-          onNewShell={() => newShell(api, store, openConsole)}
-        />
-      ),
-      () => {},
-    )
-    api.ui.dialog.setSize("xlarge")
-  }
-
-  api.keymap.registerLayer({
-    commands: [
-      {
-        name: "cockpit.shells.dock",
-        title: "Toggle shells panel",
-        category: "Shells",
-        namespace: "palette",
-        slashName: "shells",
-        run: () => toggleDock(),
-      },
-      {
-        name: "cockpit.shells.console",
-        title: "Open shell console",
-        category: "Shells",
-        namespace: "palette",
-        slashName: "shell",
-        run: () => openConsole(),
-      },
-      {
-        name: "cockpit.shells.new",
-        title: "New background shell",
-        category: "Shells",
-        namespace: "palette",
-        slashName: "shell-new",
-        run: () => newShell(api, store, openConsole),
-      },
-      {
-        name: "cockpit.shells.clear",
-        title: "Clear finished shells",
-        category: "Shells",
-        namespace: "palette",
-        slashName: "shells-clear",
-        run: () => {
-          void store
-            .clearFinished()
-            .then((n) =>
-              api.ui.toast({
-                variant: "success",
-                title: "Shells",
-                message: `Cleared ${n} finished shell${n === 1 ? "" : "s"}`,
-              }),
-            )
-            .catch((err) => api.ui.toast({ variant: "error", title: "Shells", message: String(err) }))
-        },
-      },
-      {
-        name: "cockpit.shells.restartDaemon",
-        title: "Restart shell daemon",
-        category: "Shells",
-        namespace: "palette",
-        slashName: "shells-restart-daemon",
-        run: () => restartDaemon(api, store),
-      },
-      {
-        name: "cockpit.shells.pick",
-        title: "Switch shell",
-        category: "Shells",
-        namespace: "palette",
-        run: () => pickShell(api, store, openConsole),
-      },
-    ],
-    bindings: keys.gather("cockpit", Object.keys(DEFAULT_KEYS)),
-  })
-
-  const height = () => Math.max(6, Math.min(options.dockHeight ?? 14, Math.floor(api.renderer.height * 0.45)))
-
-  api.slots.register({
-    order: 150,
-    slots: {
-      app_bottom() {
-        return (
-          <>
-            {dockOpen() ? (
-              <Dock
-                api={api}
-                store={store}
-                height={height()}
-                hint={() =>
-                  `${shortcut("cockpit.shells.console")} console · ${shortcut("cockpit.shells.dock")} hide`
-                }
-                onOpenConsole={(id) => openConsole(id)}
-              />
-            ) : null}
-          </>
-        )
-      },
-      sidebar_content() {
-        return <SidebarShells api={api} store={store} onOpen={(id) => openConsole(id)} />
-      },
-    },
-  })
-
-  // A daemon from older plugin code is kept only while it runs shells; say so once.
-  const offOutdated = client.onOutdated((info) => {
-    if (!info) return
-    api.ui.toast({
-      variant: "warning",
-      title: "Shells",
-      message:
-        "The shell daemon is running older code because shells are still running. Run /shells-restart-daemon when convenient.",
-      duration: 8000,
-    })
-  })
-
-  api.lifecycle.onDispose(() => {
-    offOutdated()
-    store.dispose()
-    client.close()
-  })
-}
-
-function newShell(api: TuiPluginApi, store: ShellStore, open: (id?: string) => void) {
-  const DialogPrompt = api.ui.DialogPrompt
-  api.ui.dialog.replace(() => (
-    <DialogPrompt
-      title="New background shell"
-      placeholder="npm run dev"
-      onConfirm={(value) => {
-        const command = value.trim()
-        if (!command) return api.ui.dialog.clear()
-        const shell =
-          process.env.SHELL && /(bash|zsh|fish|sh)$/.test(process.env.SHELL) ? process.env.SHELL : "/bin/bash"
-        store.client
-          .call("shell.start", {
-            command: shell,
-            args: ["-c", command],
-            cwd: store.project(),
-            title: command.slice(0, 60),
-            owner: { project: store.project() },
-            reuse: true,
-          })
-          .then((info) => {
-            void store.refresh()
-            open(info.id)
-          })
-          .catch((err) => {
-            api.ui.dialog.clear()
-            api.ui.toast({
-              variant: "error",
-              title: "Shell",
-              message: err instanceof Error ? err.message : String(err),
-            })
-          })
-      }}
-      onCancel={() => api.ui.dialog.clear()}
-    />
-  ))
-}
-
-function restartDaemon(api: TuiPluginApi, store: ShellStore) {
-  const running = store.shells().filter((s) => s.status === "running").length
-  const restart = (force: boolean) => {
-    api.ui.dialog.clear()
-    store.client
-      .restartDaemon({ force })
-      .then((ok) => {
-        void store.refresh()
-        api.ui.toast({
-          variant: ok ? "success" : "warning",
-          title: "Shells",
-          message: ok ? "Shell daemon restarted" : "Shells are running; restart was not forced",
-        })
-      })
-      .catch((err) => api.ui.toast({ variant: "error", title: "Shells", message: String(err) }))
-  }
-  if (running === 0) return restart(false)
-  const DialogConfirm = api.ui.DialogConfirm
-  api.ui.dialog.replace(() => (
-    <DialogConfirm
-      title="Restart shell daemon?"
-      message={`${running} running shell${running === 1 ? "" : "s"} will be stopped.`}
-      onConfirm={() => restart(true)}
-      onCancel={() => api.ui.dialog.clear()}
-    />
-  ))
-}
-
-function pickShell(api: TuiPluginApi, store: ShellStore, open: (id?: string) => void) {
-  const DialogSelect = api.ui.DialogSelect
-  const shells = order(store.shells())
-  if (shells.length === 0) {
-    api.ui.toast({ variant: "info", title: "Shells", message: "No shells in this project yet" })
-    return
-  }
-  api.ui.dialog.replace(() => (
-    <DialogSelect
-      title="Shells"
-      current={store.selected()?.id}
-      options={shells.map((s) => ({
-        title: s.title,
-        value: s.id,
-        description: `${BADGE_LABEL[kindOf(s)]} · ${displayCommand(s).slice(0, 60)}`,
-      }))}
-      onSelect={(option) => open(option.value as string)}
-    />
-  ))
-}
-
-const plugin: TuiPluginModule & { id: string } = { id: "opencode-cockpit.shell", tui: createShellTui() }
-export default plugin

package/src/tui/keys.ts

@@ -1,52 +0,0 @@
-import type { KeyEvent } from "@opentui/core"
-
-const NAMED: Record<string, string> = {
-  return: "\r",
-  enter: "\r",
-  linefeed: "\n",
-  tab: "\t",
-  backspace: "\x7f",
-  escape: "\x1b",
-  space: " ",
-  up: "\x1b[A",
-  down: "\x1b[B",
-  right: "\x1b[C",
-  left: "\x1b[D",
-  home: "\x1b[H",
-  end: "\x1b[F",
-  pageup: "\x1b[5~",
-  pagedown: "\x1b[6~",
-  delete: "\x1b[3~",
-  insert: "\x1b[2~",
-}
-
-/**
- * Re-encodes a parsed key as legacy terminal bytes. The TUI may receive keys via the kitty
- * protocol, whose raw form programs in the PTY would not understand.
- */
-export function keyToBytes(e: KeyEvent): string | undefined {
-  if (e.eventType === "release") return undefined
-  const name = e.name?.toLowerCase() ?? ""
-  if (e.name === "tab" && e.shift) return "\x1b[Z"
-  const named = NAMED[name]
-  if (named !== undefined) return e.meta || e.option ? `\x1b${named}` : named
-  if (e.ctrl && name.length === 1) {
-    const code = name.toUpperCase().charCodeAt(0)
-    if (code >= 64 && code <= 95) return String.fromCharCode(code - 64)
-  }
-  const text =
-    e.sequence && !e.sequence.startsWith("\x1b")
-      ? e.sequence
-      : name.length === 1
-        ? e.shift
-          ? name.toUpperCase()
-          : name
-        : undefined
-  if (!text) return undefined
-  return e.meta || e.option ? `\x1b${text}` : text
-}
-
-/** ctrl+] releases typing mode (the telnet escape), since esc and ctrl+c belong to the program. */
-export function isReleaseKey(e: KeyEvent): boolean {
-  return e.ctrl && (e.name === "]" || e.sequence === "\x1d")
-}

package/src/tui/sidebar.tsx

@@ -1,44 +0,0 @@
-/** @jsxImportSource @opentui/solid */
-import type { TuiPluginApi } from "@opencode-ai/plugin/tui"
-import { createMemo, For, Show } from "solid-js"
-import { Badge } from "./badge.tsx"
-import type { ShellStore } from "./store.ts"
-import { kindOf, shortDetail, truncate } from "./view.ts"
-
-export function SidebarShells(props: { api: TuiPluginApi; store: ShellStore; onOpen: (id: string) => void }) {
-  const theme = () => props.api.theme.current
-  const counts = createMemo(() => {
-    const list = props.store.shells()
-    const running = list.filter((s) => kindOf(s) === "run").length
-    const failed = props.store.visible().filter((s) => kindOf(s) === "fail").length
-    return [running ? `${running} running` : "", failed ? `${failed} failed` : ""].filter(Boolean).join(" · ")
-  })
-
-  return (
-    <Show when={props.store.shells().length > 0}>
-      <box>
-        <text fg={theme().text} wrapMode="none">
-          <b>Shells</b>
-          <span style={{ fg: theme().textMuted }}> {counts()}</span>
-        </text>
-        <For each={props.store.visible()}>
-          {(shell) => (
-            <box flexDirection="row" onMouseDown={() => props.onOpen(shell.id)}>
-              <Badge api={props.api} shell={shell} frame={props.store.frame()} />
-              <text fg={theme().text} wrapMode="none">
-                {" "}
-                {truncate(shell.title, 20)}{" "}
-                <span style={{ fg: theme().textMuted }}>{shortDetail(shell, props.store.now())}</span>
-              </text>
-            </box>
-          )}
-        </For>
-        <Show when={props.store.hidden().length > 0 || props.store.showAll()}>
-          <text fg={theme().textMuted} onMouseDown={() => props.store.toggleAll()}>
-            {props.store.showAll() ? "▾ show fewer" : `▸ ${props.store.hidden().length} more finished`}
-          </text>
-        </Show>
-      </box>
-    </Show>
-  )
-}

package/src/tui/store.ts

@@ -1,185 +0,0 @@
-import { existsSync } from "node:fs"
-import type { TuiPluginApi } from "@opencode-ai/plugin/tui"
-import type { CockpitClient } from "@opencode-cockpit/client"
-import type { ScreenResult, ShellInfo } from "@opencode-cockpit/protocol/shell"
-import { type Accessor, createEffect, createMemo, createRoot, createSignal, on, onCleanup } from "solid-js"
-import { createStore, reconcile } from "solid-js/store"
-import { order, partition } from "./view.ts"
-
-export interface ShellStore {
-  client: CockpitClient
-  project: () => string
-  /** Every shell in the project, unordered. */
-  shells: Accessor<ShellInfo[]>
-  /** Ordered and folded for display: running, recent failures, plus the selection. */
-  visible: Accessor<ShellInfo[]>
-  hidden: Accessor<ShellInfo[]>
-  showAll: Accessor<boolean>
-  toggleAll(): void
-  connected: Accessor<boolean>
-  now: Accessor<number>
-  /** Spinner frame index; advances only while something is running. */
-  frame: Accessor<number>
-  selected: Accessor<ShellInfo | undefined>
-  select(id: string): void
-  step(delta: number): void
-  refresh(): Promise<void>
-  clearFinished(): Promise<number>
-  dispose(): void
-}
-
-export interface StoreOptions {
-  /** Failures stay in the default view this long after they end. */
-  historyMinutes?: number
-}
-
-export function createShellStore(
-  api: TuiPluginApi,
-  client: CockpitClient,
-  options: StoreOptions = {},
-): ShellStore {
-  return createRoot((dispose) => {
-    const [state, setState] = createStore<{ list: ShellInfo[] }>({ list: [] })
-    const [connected, setConnected] = createSignal(false)
-    const [now, setNow] = createSignal(Date.now())
-    const [frame, setFrame] = createSignal(0)
-    const [selectedId, setSelectedId] = createSignal<string>()
-    const [showAll, setShowAll] = createSignal<boolean>(api.kv.get("cockpit.shells.showAll", false))
-    const project = () => api.state.path.directory
-    const historyMs = (options.historyMinutes ?? 30) * 60_000
-
-    const refresh = async () => {
-      try {
-        const list = await client.call("shell.list", { owner: { project: project() } })
-        setState("list", reconcile(list, { key: "id" }))
-      } catch {
-        // daemon not running yet; the reconnect loop will pick it up
-      }
-    }
-
-    const offs = [
-      client.on("shell.started", () => void refresh()),
-      client.on("shell.exited", () => void refresh()),
-      client.on("shell.removed", () => void refresh()),
-      client.onState((s) => {
-        setConnected(s === "connected")
-        if (s === "connected") void refresh()
-      }),
-    ]
-
-    // Connect only to a daemon that already exists; starting one is left to explicit actions.
-    const probe = () => {
-      if (!client.connected && existsSync(client.paths.socket)) void client.connect().catch(() => {})
-    }
-    probe()
-    const probeTimer = setInterval(probe, 3000)
-    const tick = setInterval(() => setNow(Date.now()), 1000)
-    const spin = setInterval(() => {
-      if (state.list.some((s) => s.status === "running")) setFrame((f) => f + 1)
-    }, 120)
-    onCleanup(() => {
-      clearInterval(probeTimer)
-      clearInterval(tick)
-      clearInterval(spin)
-      for (const off of offs) off()
-    })
-
-    const pick = createMemo(() => {
-      const ordered = order(state.list)
-      return ordered.find((s) => s.id === selectedId()) ?? ordered[0]
-    })
-    const folded = createMemo(() =>
-      partition(state.list, { showAll: showAll(), historyMs, now: now(), keep: pick()?.id }),
-    )
-
-    return {
-      client,
-      project,
-      shells: () => state.list,
-      visible: () => folded().visible,
-      hidden: () => folded().hidden,
-      showAll,
-      toggleAll() {
-        const next = !showAll()
-        setShowAll(next)
-        api.kv.set("cockpit.shells.showAll", next)
-      },
-      connected,
-      now,
-      frame,
-      selected: pick,
-      select: (id) => setSelectedId(id),
-      step(delta) {
-        const list = folded().visible
-        if (list.length === 0) return
-        const index = Math.max(
-          0,
-          list.findIndex((s) => s.id === pick()?.id),
-        )
-        const next = list[(index + delta + list.length) % list.length]
-        if (next) setSelectedId(next.id)
-      },
-      refresh,
-      async clearFinished() {
-        const { removed } = await client.call("shell.clear", { owner: { project: project() } })
-        await refresh()
-        return removed.length
-      },
-      dispose,
-    }
-  })
-}
-
-/**
- * Live terminal view of one shell: attaches for change notifications and re-renders the daemon's
- * emulated screen, throttled. Must be called inside a reactive owner.
- */
-export function useScreen(store: ShellStore, id: Accessor<string | undefined>) {
-  const [screen, setScreen] = createSignal<ScreenResult>()
-  let timer: ReturnType<typeof setTimeout> | undefined
-  let current: string | undefined
-
-  const fetch = (shellId: string) => {
-    timer = undefined
-    void store.client
-      .call("shell.screen", { id: shellId })
-      .then((s) => {
-        if (current === shellId) setScreen(s)
-      })
-      .catch(() => {})
-  }
-  const schedule = (shellId: string) => {
-    timer ??= setTimeout(() => fetch(shellId), 80)
-  }
-
-  const offOutput = store.client.on("shell.output", (e) => {
-    if (e.id === current) schedule(e.id)
-  })
-  const offExit = store.client.on("shell.exited", (info) => {
-    if (info.id === current) schedule(info.id)
-  })
-
-  const attach = (next: string | undefined) => {
-    if (next === current) return
-    if (current) void store.client.call("shell.detach", { id: current }).catch(() => {})
-    current = next
-    setScreen(undefined)
-    if (!next) return
-    const info = store.shells().find((s) => s.id === next)
-    void store.client
-      .call("shell.attach", { id: next, fromOffset: info?.bytes ?? Number.MAX_SAFE_INTEGER })
-      .catch(() => {})
-    fetch(next)
-  }
-
-  createEffect(on(id, (next) => attach(next)))
-
-  onCleanup(() => {
-    clearTimeout(timer)
-    offOutput()
-    offExit()
-    if (current) void store.client.call("shell.detach", { id: current }).catch(() => {})
-  })
-
-  return { screen, refetch: () => current && fetch(current) }
-}