opencode-cockpit 0.1.1 → 0.1.3

package/README.md

@@ -4,120 +4,83 @@
 [![npm](https://img.shields.io/npm/v/opencode-cockpit)](https://www.npmjs.com/package/opencode-cockpit)
 [![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/Codestz/opencode-cockpit/blob/main/LICENSE)
 
-Superpowers for [OpenCode](https://opencode.ai).
+Superpowers for [OpenCode](https://opencode.ai). Take all of them, or only the ones you want.
 
-The first one is **Shell**: background terminals that the agent starts, waits on and drives,
-and that you watch and control without leaving the chat.
-
-- **The agent stops sleeping and polling.** It starts a dev server and blocks until the port
-  opens, runs a slow test suite and gets a message when it finishes, drives REPLs and prompts.
-- **Logs that don't waste tokens.** Colours are stripped, progress-bar redraws collapse to their
-  final frame, repeated lines fold, and reads continue from a cursor.
-- **You see everything.** A docked panel under the chat, a sidebar section, and a keyboard-first
-  console with a real typing mode.
-- **Shells outlive OpenCode.** They run in a small daemon, `cockpitd`, shared by every OpenCode
-  window and restarted automatically when the plugin updates.
+| Feature | What it gives you | Package |
+|---|---|---|
+| **Shell** | Background terminals the agent starts, waits on and drives, with a docked panel and console for you | [`@opencode-cockpit/shell`](https://github.com/Codestz/opencode-cockpit/tree/main/packages/shell) |
+| **Agents** *(coming)* | A live, keyboard-first view of every subagent, without leaving your chat | `@opencode-cockpit/agents` |
 
 ## Install
 
+**Everything**
+
 ```sh
 opencode plugin opencode-cockpit --global
 ```
 
-This adds the plugin to both `opencode.json` (agent tools) and `tui.json` (interface). Restart
-OpenCode. Requires OpenCode 1.18 or newer on macOS or Linux.
+**Only what you want**
 
-## For the agent
-
-| Tool | What it does |
-|---|---|
-| `shell_start` | Run a command in a background PTY. Optional `waitFor` blocks until a port opens, a pattern prints, output goes idle, or the process exits. Rerunning the same command in the same session reuses the shell. |
-| `shell_wait` | Block on a condition instead of sleeping. |
-| `shell_read` | Clean log from a cursor, with `grep`; or `view: "screen"` for full-screen programs. |
-| `shell_send` | Type text or keys (`ctrl+c`, `up`, `enter`) and get the reply. |
-| `shell_list` · `shell_stop` · `shell_restart` | Manage shells. |
-
-The agent is messaged when a shell it started exits on its own.
-
-Things to ask:
-
-- *"Start the dev server in a background shell and wait until it's ready."*
-- *"Run the test suite in the background, keep working on the parser, tell me if it fails."*
-- *"Open a node REPL in a shell and check what `new URL('..', import.meta.url)` returns."*
+```sh
+opencode plugin @opencode-cockpit/shell --global
+```
 
-## For you
+**Everything except some features**: switch them off on the plugin entry, in both `opencode.json`
+and `tui.json`:
 
-| Key / command | Does |
-|---|---|
-| `ctrl+x o` · `/shells` | Toggle the shells panel under the chat |
-| `ctrl+x i` · `/shell` | Open the shell console |
-| `/shell-new` | Start a shell yourself |
-| `/shells-clear` | Remove finished shells |
-| `/shells-restart-daemon` | Restart `cockpitd` (asks first when shells are running) |
+```json
+{ "plugin": [["opencode-cockpit", { "features": { "shell": false } }]] }
+```
 
-Status reads the same everywhere: `RUN` (with a spinner), `FAIL`, `STOP`, `DONE`. Running shells
-and recent failures stay visible; everything else folds into `▸ N more`.
+Restart OpenCode after installing. Requires OpenCode 1.18 or newer on macOS or Linux.
 
-**Console keys.** Running shell: `i` type (every key goes to the program, `ctrl+]` to stop typing),
-`c` ctrl+c, `r` restart, `x` stop. Finished shell: `r` run again, `d` remove. Always: `tab`
-screen or log, `?` details, `[` `]` switch, `D` clear finished, `a` show all, `esc` close.
+> Install a feature **either** through `opencode-cockpit` **or** on its own, not both. If both are
+> configured, the first one loaded is used and OpenCode shows a warning telling you which entry to
+> remove.
 
-## Configuration
+## Configuring features
 
-Options go on the plugin entry in `tui.json`:
+Each feature's README lists its options. With `opencode-cockpit`, nest them under the feature's
+name:
 
 ```json
 {
   "plugin": [
-    ["opencode-cockpit", {
-      "dockHeight": 16,
-      "dockOpen": true,
-      "historyMinutes": 60,
-      "keybinds": { "cockpit.shells.dock": "<leader>j", "cockpit.shells.console": "<leader>k" }
-    }]
+    ["opencode-cockpit", { "shell": { "dockHeight": 16, "historyMinutes": 60 } }]
   ]
 }
 ```
 
-| Environment variable | Default | Purpose |
-|---|---|---|
-| `COCKPIT_HOME` | `~/.cache/opencode-cockpit` | Socket, logs, process registry |
-| `COCKPIT_IDLE_TIMEOUT_MS` | `600000` | Daemon exits after this long with no clients and no running shells |
-| `COCKPIT_LOG_LEVEL` | `info` | `debug` for verbose daemon logs |
-
-## Troubleshooting
-
-| Problem | Look at |
-|---|---|
-| Tools fail with "did not start" | `~/.cache/opencode-cockpit/cockpitd.log` |
-| Plugin not loading | newest file in `~/.local/share/opencode/log/` |
-| Panel says the daemon runs older code | `/shells-restart-daemon` once your shells are done |
+With a standalone package, put them directly on its entry:
+`["@opencode-cockpit/shell", { "dockHeight": 16 }]`.
 
 ## How it works
 
 ```
-OpenCode TUI thread ── opencode-cockpit/tui ──┐
-                                               ├── unix socket, JSON-RPC ── cockpitd ── PTYs
-OpenCode server worker ─ opencode-cockpit/server ┘
+OpenCode TUI thread ── feature plugins (tui) ──┐
+                                                ├── unix socket, JSON-RPC ── cockpitd ── processes
+OpenCode server worker ─ feature plugins (server) ┘
 ```
 
-OpenCode runs its interface and its server in separate threads, so the plugin's two halves can't
-share memory. Both talk to `cockpitd`, which owns every process. Each shell's output feeds a line
-normalizer (the agent's log), a headless terminal emulator (the screen you see) and a raw ring
-buffer (replay for late viewers). See [CONTRIBUTING.md](https://github.com/Codestz/opencode-cockpit/blob/main/CONTRIBUTING.md) for the full picture.
+Each feature is a complete OpenCode plugin. Features that need long-lived processes share one
+small daemon, `cockpitd`, which starts on demand, is shared by every OpenCode window, upgrades
+itself when a newer plugin connects and exits when idle. See [CONTRIBUTING.md](https://github.com/Codestz/opencode-cockpit/blob/main/CONTRIBUTING.md).
 
 | Package | Role |
 |---|---|
-| [`opencode-cockpit`](https://github.com/Codestz/opencode-cockpit/tree/main/packages/opencode) | The plugin: agent tools and TUI |
-| [`@opencode-cockpit/daemon`](https://github.com/Codestz/opencode-cockpit/tree/main/packages/daemon) | `cockpitd` |
-| [`@opencode-cockpit/client`](https://github.com/Codestz/opencode-cockpit/tree/main/packages/client) | Typed, auto-spawning client |
+| [`opencode-cockpit`](https://github.com/Codestz/opencode-cockpit/tree/main/packages/opencode) | All features in one plugin, each can be switched off |
+| [`@opencode-cockpit/shell`](https://github.com/Codestz/opencode-cockpit/tree/main/packages/shell) | Shell feature |
+| [`@opencode-cockpit/daemon`](https://github.com/Codestz/opencode-cockpit/tree/main/packages/daemon) | `cockpitd`, the shared process host |
+| [`@opencode-cockpit/client`](https://github.com/Codestz/opencode-cockpit/tree/main/packages/client) | Typed, auto-spawning client and shared plugin helpers |
 | [`@opencode-cockpit/protocol`](https://github.com/Codestz/opencode-cockpit/tree/main/packages/protocol) | Wire contracts |
 
 ## Roadmap
 
-- **Watchers:** `tsc`, `eslint` and `vitest` shells that report only state changes.
-- **Agents panel:** live subagent tree with a peek overlay.
-- Coloured output in the panel and console.
+- **Watchers** (Shell): `tsc`, `eslint` and `vitest` shells that report only state changes.
+- **Agents**: live subagent tree with a peek overlay.
+- **Doctor**: one command that checks your setup (duplicate features, daemon health, config) and
+  tells you how to fix it.
+- Coloured output in the Shell panel and console.
 
 ## License
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "opencode-cockpit",
-  "version": "0.1.1",
-  "description": "OpenCode superpowers: background shells the agent can start, wait on and drive, with a docked TUI panel",
+  "version": "0.1.3",
+  "description": "OpenCode superpowers, all in one: installs every opencode-cockpit feature (Shell today), each can be switched off",
   "type": "module",
   "license": "MIT",
   "author": "Codestz",
@@ -21,11 +21,12 @@
     "shell",
     "background",
     "tui",
-    "terminal"
+    "terminal",
+    "agents"
   ],
   "exports": {
     "./server": "./src/server.ts",
-    "./tui": "./src/tui/index.tsx"
+    "./tui": "./src/tui.ts"
   },
   "engines": {
     "opencode": ">=1.18.0",
@@ -40,36 +41,10 @@
     "access": "public"
   },
   "dependencies": {
-    "@opencode-cockpit/client": "0.1.1",
-    "@opencode-cockpit/daemon": "0.1.1",
-    "@opencode-cockpit/protocol": "0.1.1",
+    "@opencode-cockpit/shell": "0.1.3",
     "@opencode-ai/plugin": "1.18.31"
   },
-  "peerDependencies": {
-    "@opentui/core": ">=0.4.5",
-    "@opentui/keymap": ">=0.4.5",
-    "@opentui/solid": ">=0.4.5",
-    "solid-js": ">=1.9"
-  },
   "devDependencies": {
-    "@opentui/core": "0.4.5",
-    "@opentui/keymap": "0.4.5",
-    "@opentui/solid": "0.4.5",
-    "solid-js": "1.9.15",
-    "zod": "4.1.8"
-  },
-  "peerDependenciesMeta": {
-    "@opentui/core": {
-      "optional": true
-    },
-    "@opentui/keymap": {
-      "optional": true
-    },
-    "@opentui/solid": {
-      "optional": true
-    },
-    "solid-js": {
-      "optional": true
-    }
+    "@opencode-cockpit/client": "0.1.3"
   }
 }

package/src/compose.ts

@@ -0,0 +1,43 @@
+import type { Hooks } from "@opencode-ai/plugin"
+
+/**
+ * Merges the server hooks of several features into one plugin. Tool maps are unioned (a name
+ * clash is a bug, so it throws); function hooks run in feature order, each awaited, which is how
+ * OpenCode itself runs hooks from separate plugins.
+ */
+export function composeHooks(parts: Hooks[]): Hooks {
+  const tools: NonNullable<Hooks["tool"]> = {}
+  const functions = new Map<string, ((...args: unknown[]) => unknown)[]>()
+  const singles: Record<string, unknown> = {}
+
+  for (const part of parts) {
+    for (const [key, value] of Object.entries(part)) {
+      if (value === undefined) continue
+      if (key === "tool") {
+        for (const [id, def] of Object.entries(value as NonNullable<Hooks["tool"]>)) {
+          if (id in tools) throw new Error(`tool "${id}" is registered by more than one cockpit feature`)
+          tools[id] = def
+        }
+      } else if (typeof value === "function") {
+        const list = functions.get(key) ?? []
+        list.push(value as (...args: unknown[]) => unknown)
+        functions.set(key, list)
+      } else {
+        if (key in singles) throw new Error(`hook "${key}" is provided by more than one cockpit feature`)
+        singles[key] = value
+      }
+    }
+  }
+
+  const hooks: Record<string, unknown> = { ...singles }
+  for (const [key, list] of functions) {
+    hooks[key] =
+      list.length === 1
+        ? list[0]
+        : async (...args: unknown[]) => {
+            for (const fn of list) await fn(...args)
+          }
+  }
+  if (Object.keys(tools).length > 0) hooks.tool = tools
+  return hooks as Hooks
+}

package/src/features.ts

@@ -0,0 +1,34 @@
+/** Every feature the bundle can load. Adding one: list it here and wire it in server.ts / tui.ts. */
+export const FEATURES = ["shell"] as const
+export type Feature = (typeof FEATURES)[number]
+
+export interface CockpitOptions {
+  /** Switch features off, e.g. `{ "shell": false }`. Everything is on by default. */
+  features?: Partial<Record<Feature, boolean>>
+  /** Options passed to a single feature, keyed by feature name. */
+  shell?: Record<string, unknown>
+  [key: string]: unknown
+}
+
+export const BUNDLE = "opencode-cockpit"
+
+export function isEnabled(options: CockpitOptions | undefined, feature: Feature): boolean {
+  return options?.features?.[feature] !== false
+}
+
+/**
+ * Options for one feature. Shell also accepts options at the top level, which is where 0.1.x
+ * (when `opencode-cockpit` was Shell) read them from.
+ */
+export function featureOptions(
+  options: CockpitOptions | undefined,
+  feature: Feature,
+): Record<string, unknown> {
+  const own = (options?.[feature] as Record<string, unknown> | undefined) ?? {}
+  if (feature !== "shell" || !options) return own
+  const legacy: Record<string, unknown> = {}
+  for (const [key, value] of Object.entries(options)) {
+    if (key !== "features" && !(FEATURES as readonly string[]).includes(key)) legacy[key] = value
+  }
+  return { ...legacy, ...own }
+}

package/src/server.ts

@@ -1,98 +1,16 @@
-import type { Plugin, PluginModule } from "@opencode-ai/plugin"
-import type { ShellInfo } from "@opencode-cockpit/protocol/shell"
-import { createClient } from "./connect.ts"
-import { describeStatus, formatLines } from "./tools/format.ts"
-import { createTools } from "./tools/index.ts"
-
-const GUIDANCE = `## Background shells (opencode-cockpit)
-Long-running or interactive commands (dev servers, watchers, slow builds/tests, REPLs) go in shell_start, not bash with "&".
-Block with shell_wait (pattern, port, idle, exit) instead of sleeping; follow output with shell_read(after=cursor).
-You are messaged when a shell you started exits.`
-
-const server: Plugin = async ({ client: opencode, directory }) => {
-  const cockpit = createClient("opencode-cockpit/server")
-  const instance = crypto.randomUUID()
-  const quiet = new Set<string>()
-
-  const userShell =
-    process.env.SHELL && /(bash|zsh|fish|sh)$/.test(process.env.SHELL) ? process.env.SHELL : "/bin/bash"
-  const env = () => {
-    const out: Record<string, string> = {}
-    for (const [k, v] of Object.entries(process.env))
-      if (v !== undefined && !k.startsWith("OPENCODE_")) out[k] = v
-    return out
-  }
-
-  // Wake the agent when a shell it owns ends on its own.
-  cockpit.on("shell.exited", (info) => {
-    if (info.owner.instance !== instance || !info.owner.session) return
-    if (quiet.delete(info.id)) return
-    void notifyExit(info).catch(() => {})
-  })
-
-  async function notifyExit(info: ShellInfo): Promise<void> {
-    const session = info.owner.session as string
-    const page = await cockpit.call("shell.read", { id: info.id, tail: 15 })
-    const failed =
-      info.status === "failed" ||
-      (info.status === "exited" && info.exitCode !== 0) ||
-      info.status === "killed"
-    const text = [
-      `<shell_exited id="${info.id}" title="${info.title}">`,
-      describeStatus(info),
-      page.lines.length > 0 ? `last output:\n${formatLines(page.lines)}` : "(no output)",
-      "</shell_exited>",
-      failed
-        ? `Investigate with shell_read id=${info.id} grep="error|fail" if the failure matters to the task.`
-        : `Full output: shell_read id=${info.id}.`,
-    ].join("\n")
-    await opencode.session.promptAsync({
-      path: { id: session },
-      body: { parts: [{ type: "text", text, synthetic: true } as never] },
-    })
-  }
-
-  return {
-    tool: createTools({
-      client: cockpit,
-      instance,
-      quiet,
-      env,
-      shellCommand: (command) => ({ command: userShell, args: ["-c", command] }),
-    }),
-
-    "experimental.chat.system.transform": async (_input, output) => {
-      output.system.push(GUIDANCE)
-      const running = await cockpit
-        .call("shell.list", { owner: { project: directory }, includeExited: false })
-        .catch(() => [] as ShellInfo[])
-      if (running.length > 0) {
-        output.system.push(
-          `Background shells currently running in this project:\n${running
-            .slice(0, 15)
-            .map((s) => `- ${s.id} ${s.title} (${describeStatus(s)})`)
-            .join("\n")}`,
-        )
-      }
-    },
-
-    event: async ({ event }) => {
-      if (event.type !== "session.deleted") return
-      const sessionID = event.properties.info.id
-      const owned = await cockpit
-        .call("shell.list", { owner: { session: sessionID } })
-        .catch(() => [] as ShellInfo[])
-      for (const shell of owned) {
-        quiet.add(shell.id)
-        await cockpit.call("shell.remove", { id: shell.id }).catch(() => {})
-      }
-    },
-
-    dispose: async () => {
-      cockpit.close()
-    },
-  }
+import type { Hooks, Plugin, PluginModule } from "@opencode-ai/plugin"
+import { createShellServer } from "@opencode-cockpit/shell/server"
+import { composeHooks } from "./compose.ts"
+import { BUNDLE, type CockpitOptions, featureOptions, isEnabled } from "./features.ts"
+
+const shell = createShellServer({ source: BUNDLE })
+
+const server: Plugin = async (input, rawOptions) => {
+  const options = rawOptions as CockpitOptions | undefined
+  const parts: Hooks[] = []
+  if (isEnabled(options, "shell")) parts.push(await shell(input, featureOptions(options, "shell")))
+  return composeHooks(parts)
 }
 
-const plugin: PluginModule & { id: string } = { id: "opencode-cockpit", server }
+const plugin: PluginModule & { id: string } = { id: BUNDLE, server }
 export default plugin

package/src/tui.ts

@@ -0,0 +1,13 @@
+import type { TuiPlugin, TuiPluginModule } from "@opencode-ai/plugin/tui"
+import { createShellTui } from "@opencode-cockpit/shell/tui"
+import { BUNDLE, type CockpitOptions, featureOptions, isEnabled } from "./features.ts"
+
+const shell = createShellTui({ source: BUNDLE })
+
+const tui: TuiPlugin = async (api, rawOptions, meta) => {
+  const options = rawOptions as CockpitOptions | undefined
+  if (isEnabled(options, "shell")) await shell(api, featureOptions(options, "shell"), meta)
+}
+
+const plugin: TuiPluginModule & { id: string } = { id: BUNDLE, tui }
+export default plugin

package/src/connect.ts

@@ -1,24 +0,0 @@
-import { fileURLToPath } from "node:url"
-import { CockpitClient } from "@opencode-cockpit/client"
-import daemonPkg from "@opencode-cockpit/daemon/package.json" with { type: "json" }
-import { daemonBuildId } from "@opencode-cockpit/protocol"
-import pkg from "../package.json" with { type: "json" }
-
-/** Resolves the daemon entry shipped with this package. */
-export function daemonEntry(): string {
-  return fileURLToPath(import.meta.resolve("@opencode-cockpit/daemon/main"))
-}
-
-/**
- * Inside OpenCode `process.execPath` is the OpenCode binary; the client starts the daemon with
- * BUN_BE_BUN=1 so it runs on OpenCode's embedded Bun (ADR 0001). The expected build lets the
- * client replace a daemon left running from older plugin code.
- */
-export function createClient(name: string): CockpitClient {
-  const entry = daemonEntry()
-  return new CockpitClient({
-    client: { name, version: pkg.version, pid: process.pid },
-    spawn: { entry, execPath: process.execPath },
-    expectedBuild: daemonBuildId(entry, daemonPkg.version),
-  })
-}

package/src/tools/format.ts

@@ -1,78 +0,0 @@
-import type { LogLine, ReadResult, ShellInfo, WaitResult } from "@opencode-cockpit/protocol/shell"
-
-const MAX_LINE = 2000
-
-/** Compact log lines for a model: numbered, long lines cut, consecutive repeats collapsed. */
-export function formatLines(lines: LogLine[]): string {
-  const out: string[] = []
-  let i = 0
-  while (i < lines.length) {
-    const line = lines[i] as LogLine
-    let j = i + 1
-    while (j < lines.length && (lines[j] as LogLine).text === line.text) j++
-    const repeats = j - i
-    const text =
-      line.text.length > MAX_LINE
-        ? `${line.text.slice(0, MAX_LINE)}… [${line.text.length - MAX_LINE} chars cut]`
-        : line.text
-    out.push(
-      repeats > 1
-        ? `${line.n}| ${text}  (×${repeats}, lines ${line.n}-${line.n + repeats - 1})`
-        : `${line.n}| ${text}`,
-    )
-    i = j
-  }
-  return out.join("\n")
-}
-
-export function describeStatus(info: ShellInfo): string {
-  switch (info.status) {
-    case "running":
-      return `running (pid ${info.pid}, up ${duration(Date.now() - info.startedAt)})`
-    case "exited":
-      return `exited with code ${info.exitCode ?? "?"} after ${duration((info.endedAt ?? Date.now()) - info.startedAt)}`
-    case "killed":
-      return `killed${info.signal ? ` by ${info.signal}` : ""} after ${duration((info.endedAt ?? Date.now()) - info.startedAt)}`
-    case "failed":
-      return `failed to start: ${info.error ?? "unknown error"}`
-  }
-}
-
-export function header(info: ShellInfo): string {
-  const run = info.run > 1 ? ` run=${info.run}` : ""
-  return `<shell id="${info.id}" title="${info.title.replaceAll('"', "'")}" status="${info.status}"${run}>`
-}
-
-export function formatRead(info: ShellInfo, page: ReadResult, empty = "(no output yet)"): string {
-  const parts = [header(info), `status: ${describeStatus(info)}`]
-  if (page.truncated)
-    parts.push(`(older lines were dropped from the buffer; oldest kept is ${page.firstLine})`)
-  parts.push(page.lines.length > 0 ? formatLines(page.lines) : empty)
-  if (page.hasMore) parts.push(`(more lines available: call shell_read with after=${page.nextCursor})`)
-  parts.push("</shell>", `cursor: ${page.nextCursor}`)
-  return parts.join("\n")
-}
-
-export function formatWait(result: WaitResult, timeoutSeconds: number): string {
-  switch (result.reason) {
-    case "pattern":
-      return `condition met: pattern matched on line ${result.match?.n}: ${result.match?.text}`
-    case "port":
-      return "condition met: port is accepting connections"
-    case "idle":
-      return "condition met: no output for the idle window (the program may be waiting for input)"
-    case "exit":
-      return `process ended: ${describeStatus(result.info)}`
-    case "timeout":
-      return `timed out after ${timeoutSeconds}s without the condition being met; the shell is still ${result.info.status}`
-  }
-}
-
-export function duration(ms: number): string {
-  const s = Math.max(0, Math.round(ms / 1000))
-  if (s < 60) return `${s}s`
-  const m = Math.floor(s / 60)
-  if (m < 60) return `${m}m${s % 60 ? `${s % 60}s` : ""}`
-  const h = Math.floor(m / 60)
-  return `${h}h${m % 60 ? `${m % 60}m` : ""}`
-}