@opencode-cockpit/shell 0.1.4 → 0.2.0

package/types/tui/lib/view.d.ts

@@ -0,0 +1,80 @@
+import type { TuiThemeCurrent } from "@opencode-ai/plugin/tui";
+import type { ScreenRun, ShellInfo } from "@opencode-cockpit/protocol/shell";
+/** What a human cares about, derived from status + exit code so every surface agrees. */
+export type Kind = "run" | "fail" | "stop" | "done";
+export declare function kindOf(s: ShellInfo): Kind;
+export declare const BADGE_LABEL: Record<Kind, string>;
+/** Braille spinner: single-width in every terminal font. */
+export declare const SPINNER: string[];
+export declare function kindColor(theme: TuiThemeCurrent, kind: Kind): import("@opentui/core").RGBA;
+/** Fixed 7-column pill so lists line up: " ⠹ RUN ", " FAIL  ". */
+export declare function badgeText(kind: Kind, frame?: number): string;
+/** Running first (oldest first, stable tabs), then failures, stopped, done (most recent first). */
+export declare function order(list: readonly ShellInfo[]): ShellInfo[];
+export interface PartitionOptions {
+    showAll: boolean;
+    /** Failures stay visible this long after they end. */
+    historyMs: number;
+    now: number;
+    /** Always visible, so the selection never disappears under the user. */
+    keep?: string;
+}
+/** Default view: running shells and recent failures. Everything else folds into a "N more" chip. */
+export declare function partition(list: readonly ShellInfo[], opts: PartitionOptions): {
+    visible: {
+        id: string;
+        title: string;
+        command: string;
+        args: string[];
+        cwd: string;
+        owner: {
+            project: string;
+            session?: string | undefined;
+            instance?: string | undefined;
+        };
+        status: "exited" | "failed" | "killed" | "running";
+        run: number;
+        pid?: number | undefined;
+        exitCode?: number | undefined;
+        signal?: string | undefined;
+        error?: string | undefined;
+        summary?: string | undefined;
+        startedAt: number;
+        endedAt?: number | undefined;
+        cols: number;
+        rows: number;
+        lines: {
+            first: number;
+            last: number;
+        };
+        bytes: number;
+        watch?: {
+            preset?: string | undefined;
+            status: "fail" | "ok" | "pending" | "unknown";
+            summary?: string | undefined;
+            runs: number;
+            since: number;
+        } | undefined;
+        logFile?: string | undefined;
+    }[];
+    hidden: ShellInfo[];
+};
+export declare function statusDetail(s: ShellInfo, now: number): string;
+/** Short health label for a watched shell, e.g. "tsc ✗" — empty when nothing is watching it. */
+export declare function watchLabel(s: ShellInfo): string;
+export declare function watchColor(theme: TuiThemeCurrent, s: ShellInfo): import("@opentui/core").RGBA;
+/** Compact detail for narrow lists. */
+export declare function shortDetail(s: ShellInfo, now: number): string;
+/** Coarse relative time: "just now", "12s ago", "9m ago", "3h ago". */
+export declare function since(ms: number): string;
+/** The command as the user or agent wrote it, without the `$SHELL -c` wrapper. */
+export declare function displayCommand(s: ShellInfo): string;
+/** Folder relative to the project: "" at the root, "./sub" inside, "~/x" elsewhere under home. */
+export declare function relativeCwd(cwd: string, project: string, home?: string): string;
+/** Hard-wraps to `width`, at most `maxLines`; the last line ends with … when text was cut. */
+export declare function wrapText(text: string, width: number, maxLines: number): string[];
+/** Last `rows` styled rows, each cut to `cols`, so colour survives the same trimming as text. */
+export declare function tailRuns(styled: ScreenRun[][] | undefined, rows: number, cols: number): ScreenRun[][];
+/** Last `rows` lines of screen text, each cut to `cols`. */
+export declare function tailLines(text: string | undefined, rows: number, cols: number): string;
+export declare function truncate(text: string, max: number): string;

package/types/tui/state/store.d.ts

@@ -0,0 +1,55 @@
+import type { TuiPluginApi } from "@opencode-ai/plugin/tui";
+import type { CockpitClient } from "@opencode-cockpit/client";
+import type { ShellInfo } from "@opencode-cockpit/protocol/shell";
+import { type Accessor } from "solid-js";
+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 declare function createShellStore(api: TuiPluginApi, client: CockpitClient, options?: StoreOptions): ShellStore;
+/**
+ * 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 declare function useScreen(store: ShellStore, id: Accessor<string | undefined>): {
+    screen: Accessor<{
+        text: string;
+        cols: number;
+        rows: number;
+        cursor: {
+            x: number;
+            y: number;
+        };
+        styled?: {
+            text: string;
+            fg?: string | undefined;
+            bg?: string | undefined;
+            bold?: boolean | undefined;
+            dim?: boolean | undefined;
+            italic?: boolean | undefined;
+            underline?: boolean | undefined;
+        }[][] | undefined;
+    } | undefined>;
+    refetch: () => void | "" | undefined;
+};

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/server.ts

@@ -1,156 +0,0 @@
-import type { Hooks, Plugin, PluginInput, PluginModule } from "@opencode-ai/plugin"
-import { claimFeature, duplicateFeatureMessage } from "@opencode-cockpit/client"
-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.`
-
-export const SHELL_PACKAGE = "@opencode-cockpit/shell"
-
-export interface ShellServerOptions {
-  /** Package that loaded Shell, reported when a duplicate copy is skipped. */
-  source?: string
-}
-
-/** Shell's server half as a factory, so bundles such as `opencode-cockpit` can include it. */
-export function createShellServer({ source = SHELL_PACKAGE }: ShellServerOptions = {}): Plugin {
-  return async (input) => {
-    const claim = claimFeature(input, "shell", source)
-    if (!claim.active) {
-      // Logging through the server during plugin initialisation could wait on ourselves; defer it.
-      setTimeout(() => {
-        void input.client.app
-          .log({
-            body: {
-              service: "opencode-cockpit",
-              level: "warn",
-              message: duplicateFeatureMessage("Shell", claim.owner, source),
-            },
-          })
-          .catch(() => {})
-      }, 0)
-      return {}
-    }
-    const hooks = await shellHooks(input)
-    const dispose = hooks.dispose
-    return {
-      ...hooks,
-      dispose: async () => {
-        claim.release()
-        await dispose?.()
-      },
-    }
-  }
-}
-
-async function shellHooks({ client: opencode, directory }: PluginInput): Promise<Hooks> {
-  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
-  }
-
-  // Session titles rarely change; cache them so listing shells stays one round trip.
-  const titles = new Map<string, { title: string | undefined; at: number }>()
-  const sessionTitle = async (sessionID: string): Promise<string | undefined> => {
-    const hit = titles.get(sessionID)
-    if (hit && Date.now() - hit.at < 60_000) return hit.title
-    const result = await opencode.session.get({ path: { id: sessionID } }).catch(() => undefined)
-    const title = (result?.data as { title?: string } | undefined)?.title
-    titles.set(sessionID, { title, at: Date.now() })
-    return title
-  }
-
-  // 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,
-      sessionTitle,
-      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) => {
-              const from = !s.owner.session
-                ? ", started by the user"
-                : s.owner.session === input.sessionID
-                  ? ""
-                  : ", another session"
-              return `- ${s.id} "${s.title}" (${describeStatus(s)}${from})`
-            })
-            .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()
-    },
-  }
-}
-
-const plugin: PluginModule & { id: string } = { id: "opencode-cockpit.shell", server: createShellServer() }
-export default plugin

package/src/tools/find.ts

@@ -1,80 +0,0 @@
-import type { ShellInfo } from "@opencode-cockpit/protocol/shell"
-
-/** The command as written, without the `$SHELL -c` wrapper. */
-export function commandOf(s: ShellInfo): string {
-  return s.args.length === 2 && s.args[0] === "-c" ? (s.args[1] as string) : [s.command, ...s.args].join(" ")
-}
-
-export type StatusFilter = "running" | "failed" | "finished" | "any"
-export type SessionFilter = "this" | "others" | "any"
-
-export interface ShellFilter {
-  /** Case-insensitive text found in the name or the command. */
-  query?: string
-  status?: StatusFilter
-  session?: SessionFilter
-  /** The asking agent's session, for `session` filtering. */
-  currentSession?: string
-}
-
-export function isFailed(s: ShellInfo): boolean {
-  return s.status === "failed" || (s.status === "exited" && s.exitCode !== 0)
-}
-
-export function filterShells(list: readonly ShellInfo[], filter: ShellFilter): ShellInfo[] {
-  const query = filter.query?.trim().toLowerCase()
-  return list.filter((s) => {
-    if (query && !s.title.toLowerCase().includes(query) && !commandOf(s).toLowerCase().includes(query)) {
-      return false
-    }
-    switch (filter.status ?? "any") {
-      case "running":
-        if (s.status !== "running") return false
-        break
-      case "failed":
-        if (!isFailed(s)) return false
-        break
-      case "finished":
-        if (s.status === "running") return false
-        break
-    }
-    switch (filter.session ?? "any") {
-      case "this":
-        return s.owner.session === filter.currentSession
-      case "others":
-        return s.owner.session !== filter.currentSession
-      default:
-        return true
-    }
-  })
-}
-
-export type NameMatch =
-  | { kind: "found"; shell: ShellInfo; alsoMatched: ShellInfo[] }
-  | { kind: "ambiguous"; candidates: ShellInfo[] }
-  | { kind: "none"; available: ShellInfo[] }
-
-/**
- * Finds the shell a name refers to. Exact names (ignoring case) beat partial matches on name or
- * command. When several match, a single running shell is the obvious intent (earlier finished
- * shells with the same name are history); otherwise the caller must choose.
- */
-export function matchByName(list: readonly ShellInfo[], name: string): NameMatch {
-  const wanted = name.trim().toLowerCase()
-  const exact = list.filter((s) => s.title.trim().toLowerCase() === wanted)
-  const matches =
-    exact.length > 0
-      ? exact
-      : list.filter(
-          (s) => s.title.toLowerCase().includes(wanted) || commandOf(s).toLowerCase().includes(wanted),
-        )
-
-  if (matches.length === 0) return { kind: "none", available: [...list] }
-  if (matches.length === 1) return { kind: "found", shell: matches[0] as ShellInfo, alsoMatched: [] }
-  const running = matches.filter((s) => s.status === "running")
-  if (running.length === 1) {
-    const shell = running[0] as ShellInfo
-    return { kind: "found", shell, alsoMatched: matches.filter((s) => s !== shell) }
-  }
-  return { kind: "ambiguous", candidates: matches }
-}

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` : ""}`
-}