@opencode-cockpit/shell 0.1.5 → 0.2.0

package/dist/tui/{view.js → lib/view.js}

@@ -1,4 +1,4 @@
-import { duration } from "../tools/format.js";
+import { duration } from "../../core/format.js";
 
 /** What a human cares about, derived from status + exit code so every surface agrees. */
 
@@ -88,6 +88,24 @@ export function statusDetail(s, now) {
   }
 }
 
+/** Short health label for a watched shell, e.g. "tsc ✗" — empty when nothing is watching it. */
+export function watchLabel(s) {
+  const watch = s.watch;
+  if (!watch || watch.status === "pending") return "";
+  const mark = watch.status === "ok" ? "✓" : watch.status === "fail" ? "✗" : "?";
+  return `${watch.preset ?? "watch"} ${mark}`;
+}
+export function watchColor(theme, s) {
+  switch (s.watch?.status) {
+    case "ok":
+      return theme.success;
+    case "fail":
+      return theme.error;
+    default:
+      return theme.textMuted;
+  }
+}
+
 /** Compact detail for narrow lists. */
 export function shortDetail(s, now) {
   switch (kindOf(s)) {
@@ -143,6 +161,25 @@ export function wrapText(text, width, maxLines) {
   return lines;
 }
 
+/** Last `rows` styled rows, each cut to `cols`, so colour survives the same trimming as text. */
+export function tailRuns(styled, rows, cols) {
+  if (!styled) return [];
+  return styled.slice(Math.max(0, styled.length - rows)).map(row => {
+    const out = [];
+    let width = 0;
+    for (const run of row) {
+      if (width >= cols) break;
+      const text = run.text.slice(0, cols - width);
+      width += text.length;
+      out.push({
+        ...run,
+        text
+      });
+    }
+    return out;
+  });
+}
+
 /** Last `rows` lines of screen text, each cut to `cols`. */
 export function tailLines(text, rows, cols) {
   if (!text) return "";

package/dist/tui/{store.js → state/store.js}

@@ -1,7 +1,7 @@
 import { existsSync } from "node:fs";
 import { createEffect, createMemo, createRoot, createSignal, on, onCleanup } from "solid-js";
 import { createStore, reconcile } from "solid-js/store";
-import { order, partition } from "./view.js";
+import { order, partition } from "../lib/view.js";
 export function createShellStore(api, client, options = {}) {
   return createRoot(dispose => {
     const [state, setState] = createStore({
@@ -76,8 +76,10 @@ export function createShellStore(api, client, options = {}) {
       frame,
       selected: pick,
       select: id => setSelectedId(id),
+      // Cycles every shell in the project: folding only exists to keep the sidebar short, and a
+      // shell you cannot reach from the console would be a trap.
       step(delta) {
-        const list = folded().visible;
+        const list = order(state.list);
         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];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opencode-cockpit/shell",
-  "version": "0.1.5",
+  "version": "0.2.0",
   "description": "Background shells for OpenCode: the agent starts, waits on and drives PTYs; you watch them in a docked TUI panel",
   "type": "module",
   "license": "MIT",
@@ -51,13 +51,12 @@
     "access": "public"
   },
   "dependencies": {
-    "@opencode-cockpit/client": "0.1.5",
-    "@opencode-cockpit/daemon": "0.1.5",
-    "@opencode-cockpit/protocol": "0.1.5",
+    "@opencode-cockpit/client": "0.2.0",
+    "@opencode-cockpit/daemon": "0.2.0",
+    "@opencode-cockpit/protocol": "0.2.0",
     "@opencode-ai/plugin": "1.18.31"
   },
   "devDependencies": {
-    "zod": "4.6.5",
     "@opentui/core": "0.4.5",
     "@opentui/keymap": "0.4.5",
     "@opentui/solid": "0.4.5",

package/types/agent/plugin.d.ts

@@ -0,0 +1,12 @@
+import type { Plugin, PluginModule } from "@opencode-ai/plugin";
+export declare 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 declare function createShellServer({ source }?: ShellServerOptions): Plugin;
+declare const plugin: PluginModule & {
+    id: string;
+};
+export default plugin;

package/types/agent/tools/index.d.ts

@@ -0,0 +1,5 @@
+import type { ToolDefinition } from "@opencode-ai/plugin";
+import { type ToolDeps } from "./shared.ts";
+export type { ToolDeps } from "./shared.ts";
+/** The shell tools an agent sees. One file per tool; `shared.ts` holds what they have in common. */
+export declare function createTools(deps: ToolDeps): Record<string, ToolDefinition>;

package/types/agent/tools/list.d.ts

@@ -0,0 +1,3 @@
+import { type ToolDefinition } from "@opencode-ai/plugin";
+import type { ToolKit } from "./shared.ts";
+export declare function shellList(kit: ToolKit): ToolDefinition;

package/types/agent/tools/read.d.ts

@@ -0,0 +1,3 @@
+import { type ToolDefinition } from "@opencode-ai/plugin";
+import type { ToolKit } from "./shared.ts";
+export declare function shellRead(kit: ToolKit): ToolDefinition;

package/types/agent/tools/restart.d.ts

@@ -0,0 +1,3 @@
+import { type ToolDefinition } from "@opencode-ai/plugin";
+import { type ToolKit } from "./shared.ts";
+export declare function shellRestart(kit: ToolKit): ToolDefinition;

package/types/agent/tools/send.d.ts

@@ -0,0 +1,3 @@
+import { type ToolDefinition } from "@opencode-ai/plugin";
+import { type ToolKit } from "./shared.ts";
+export declare function shellSend(kit: ToolKit): ToolDefinition;

package/types/agent/tools/shared.d.ts

@@ -0,0 +1,40 @@
+import type { ToolContext } from "@opencode-ai/plugin";
+import type { CockpitClient } from "@opencode-cockpit/client";
+import type { ShellInfo } from "@opencode-cockpit/protocol/shell";
+import type { CockpitConfig } from "../../core/config.ts";
+export interface ToolDeps {
+    client: CockpitClient;
+    /** Identifies this OpenCode instance so only it notifies the owning session. */
+    instance: string;
+    /** Shells whose exit should not message the agent (it stopped them itself, or opted out). */
+    quiet: Set<string>;
+    shellCommand(command: string): {
+        command: string;
+        args: string[];
+    };
+    env(): Record<string, string>;
+    /** Settings that shape defaults, kinds and watch presets. */
+    config?: CockpitConfig;
+    /** Human title of an OpenCode session, for telling agents which session started a shell. */
+    sessionTitle?(sessionID: string): Promise<string | undefined>;
+}
+/** What every tool shares: the client, name resolution, permission prompts and abort handling. */
+export interface ToolKit {
+    deps: ToolDeps;
+    /** Settings from ~/.config/opencode-cockpit/config.json, .cockpit.json and plugin options. */
+    config: CockpitConfig;
+    client: CockpitClient;
+    peek(info: ShellInfo, tail?: number): Promise<string>;
+    sessionLabel(shell: ShellInfo, ctx: ToolContext): Promise<string>;
+    resolve(args: {
+        id?: string | null;
+        name?: string | null;
+    }, ctx: ToolContext): Promise<{
+        id: string;
+        note: string;
+    }>;
+}
+export declare function createToolKit(deps: ToolDeps): ToolKit;
+export declare function askPermission(ctx: ToolContext, command: string): Promise<void>;
+/** Resolves undefined when the tool call is aborted; the daemon keeps running the shell. */
+export declare function abortable<T>(ctx: ToolContext, promise: Promise<T>): Promise<T | undefined>;

package/types/agent/tools/start.d.ts

@@ -0,0 +1,3 @@
+import { type ToolDefinition } from "@opencode-ai/plugin";
+import { type ToolKit } from "./shared.ts";
+export declare function shellStart(kit: ToolKit): ToolDefinition;

package/types/agent/tools/stop.d.ts

@@ -0,0 +1,3 @@
+import { type ToolDefinition } from "@opencode-ai/plugin";
+import type { ToolKit } from "./shared.ts";
+export declare function shellStop(kit: ToolKit): ToolDefinition;

package/types/agent/tools/wait.d.ts

@@ -0,0 +1,3 @@
+import { type ToolDefinition } from "@opencode-ai/plugin";
+import { type ToolKit } from "./shared.ts";
+export declare function shellWait(kit: ToolKit): ToolDefinition;

package/types/agent/tools/watch-args.d.ts

@@ -0,0 +1,10 @@
+import type { WatchRule } from "@opencode-cockpit/protocol/shell";
+import type { CockpitConfig } from "../../core/config.ts";
+/**
+ * Turns a preset name into what `shell.watch` needs. A preset defined in config is sent as an
+ * explicit rule, so users can add tools or correct a built-in without touching the daemon.
+ */
+export declare function watchArgs(preset: string, config: CockpitConfig): {
+    preset?: string;
+    rule?: WatchRule;
+};

package/types/agent/tools/watch.d.ts

@@ -0,0 +1,3 @@
+import { type ToolDefinition } from "@opencode-ai/plugin";
+import type { ToolKit } from "./shared.ts";
+export declare function shellWatch(kit: ToolKit): ToolDefinition;

package/types/core/config.d.ts

@@ -0,0 +1,59 @@
+import type { WatchRule } from "@opencode-cockpit/protocol/shell";
+/**
+ * Settings, read from one file so they are written once instead of twice (OpenCode keeps agent and
+ * TUI plugins in separate configs). Precedence, lowest first:
+ *
+ *   ~/.config/opencode-cockpit/config.json  →  <project>/.cockpit.json  →  plugin-entry options
+ *
+ * Everything is optional, and an unreadable or invalid file is ignored rather than fatal: a typo in
+ * a config should never stop shells from working.
+ */
+export interface CockpitConfig {
+    /** Health watching (see shell_watch). */
+    watch?: {
+        /** Attach a matching preset to every new shell without being asked. Off by default. */
+        auto?: boolean;
+        /** Extra rules, or replacements for built-ins, keyed by preset name. */
+        presets?: Record<string, WatchRule>;
+    };
+    /** Extra shell kinds, or overrides, as name → regular expression matched against the command. */
+    kinds?: Record<string, string>;
+    /** Applied to every shell the agent starts, unless the call says otherwise. */
+    defaults?: {
+        watch?: boolean | string;
+        logFile?: boolean;
+        idleTimeoutSeconds?: number;
+        timeoutSeconds?: number;
+        notifyOnExit?: boolean;
+    };
+    /** What is allowed to interrupt the agent. */
+    notify?: {
+        exit?: boolean;
+        watch?: boolean;
+        /** Output lines included in an exit message. */
+        tailLines?: number;
+    };
+    /** The system-prompt guidance that teaches the agent to use shells (~120 tokens per request). */
+    guidance?: boolean;
+    /** Running shells listed in the system prompt each turn; 0 disables (~20 tokens each). */
+    listRunningShells?: number;
+    /** Interface options; also settable on the tui.json plugin entry. */
+    ui?: {
+        dockHeight?: number;
+        dockOpen?: boolean;
+        sidebarRows?: number;
+        historyMinutes?: number;
+        colors?: boolean;
+        defaultView?: "screen" | "log";
+        keybinds?: Record<string, string>;
+        updateCheck?: boolean;
+    };
+}
+export declare const CONFIG_FILE = "config.json";
+export declare const PROJECT_FILE = ".cockpit.json";
+export declare function globalConfigPath(env?: Record<string, string | undefined>): string;
+/** Reads and merges every source. `options` is the plugin entry's own options object. */
+export declare function loadConfig(directory: string, options?: unknown, env?: Record<string, string | undefined>): CockpitConfig;
+export declare function readConfigFile(path: string): CockpitConfig;
+/** Section-wise merge: later sources win key by key, and never lose a whole section. */
+export declare function mergeConfig(base: CockpitConfig, over: CockpitConfig): CockpitConfig;

package/types/{tools → core}/find.d.ts

@@ -1,15 +1,20 @@
 import type { ShellInfo } from "@opencode-cockpit/protocol/shell";
+import { type ShellKind } from "./kind.ts";
 /** The command as written, without the `$SHELL -c` wrapper. */
 export declare function commandOf(s: ShellInfo): string;
 export type StatusFilter = "running" | "failed" | "finished" | "any";
 export type SessionFilter = "this" | "others" | "any";
 export interface ShellFilter {
+    /** What the shell is, derived from its command (server, tests, build, watcher, task). */
+    kind?: ShellKind | "any";
     /** 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;
+    /** Extra kind patterns from config, so a kind it defines is also filterable. */
+    kinds?: Record<string, string>;
 }
 export declare function isFailed(s: ShellInfo): boolean;
 export declare function filterShells(list: readonly ShellInfo[], filter: ShellFilter): ShellInfo[];

package/types/core/kind.d.ts

@@ -0,0 +1,9 @@
+import type { ShellInfo } from "@opencode-cockpit/protocol/shell";
+/** What a shell is, derived from its command — never a label anyone has to maintain by hand. */
+export type ShellKind = "server" | "tests" | "watcher" | "build" | "task" | (string & {});
+/**
+ * Order matters: a test runner in watch mode is still about tests, and `vite build` is a build even
+ * though `vite` usually serves.
+ */
+export declare function classify(command: string, custom?: Record<string, string>): ShellKind;
+export declare function kindOfShell(s: ShellInfo, custom?: Record<string, string>): ShellKind;

package/types/server.d.ts

@@ -1,12 +1,2 @@
-import type { Plugin, PluginModule } from "@opencode-ai/plugin";
-export declare 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 declare function createShellServer({ source }?: ShellServerOptions): Plugin;
-declare const plugin: PluginModule & {
-    id: string;
-};
-export default plugin;
+/** Published entry point: `@opencode-cockpit/shell/server`. */
+export { createShellServer, default, SHELL_PACKAGE, type ShellServerOptions } from "./agent/plugin.ts";

package/types/tui/{console.d.ts → components/console.d.ts}

@@ -1,16 +1,22 @@
 /** @jsxImportSource @opentui/solid */
 import type { TuiPluginApi } from "@opencode-ai/plugin/tui";
-import { type ShellStore } from "./store.ts";
+import { type ShellStore } from "../state/store.ts";
 export interface ConsoleProps {
     api: TuiPluginApi;
     store: ShellStore;
     /** Start in typing mode. */
     typing?: boolean;
+    /** Paint the colours programs print (config: ui.colors). */
+    colors?: boolean;
+    /** Which view a freshly opened console shows (config: ui.defaultView). */
+    defaultView?: "screen" | "log";
     onClose: () => void;
     onNewShell: () => void;
 }
+/** Splits a line into plain and matching parts so a filtered log can highlight what matched. */
 /**
  * Keyboard-first shell console in an overlay. Normal mode: single-key actions. Typing mode:
  * every key goes to the program (ctrl+c included); ctrl+] returns to normal mode.
  */
 export declare function Console(props: ConsoleProps): import("solid-js").JSX.Element;
+/** Everything about a shell, with the full command wrapped rather than cut. */

package/types/tui/{dock.d.ts → components/dock.d.ts}

@@ -1,10 +1,12 @@
 /** @jsxImportSource @opentui/solid */
 import type { TuiPluginApi } from "@opencode-ai/plugin/tui";
-import type { ShellStore } from "./store.ts";
+import type { ShellStore } from "../state/store.ts";
 export interface DockProps {
     api: TuiPluginApi;
     store: ShellStore;
     height: number;
+    /** Paint the colours programs print (config: ui.colors). */
+    colors?: boolean;
     hint: () => string;
     onOpenConsole: (id: string) => void;
 }

package/types/tui/{sidebar.d.ts → components/sidebar.d.ts}

@@ -1,6 +1,6 @@
 /** @jsxImportSource @opentui/solid */
 import type { TuiPluginApi } from "@opencode-ai/plugin/tui";
-import type { ShellStore } from "./store.ts";
+import type { ShellStore } from "../state/store.ts";
 export interface SidebarProps {
     api: TuiPluginApi;
     store: ShellStore;

package/types/tui/dialogs.d.ts

@@ -0,0 +1,10 @@
+/** @jsxImportSource @opentui/solid */
+import type { TuiPluginApi, TuiPluginMeta } from "@opencode-ai/plugin/tui";
+import type { ShellStore } from "./state/store.ts";
+/** One quiet registry check a day; a newer release is announced once per version. */
+export declare function announceUpdate(api: TuiPluginApi, meta: TuiPluginMeta, current: string): Promise<void>;
+/** Clears this plugin's cache entry so the next OpenCode start installs the newer release. */
+export declare function offerUpdate(api: TuiPluginApi, meta: TuiPluginMeta, current: string): void;
+export declare function newShell(api: TuiPluginApi, store: ShellStore, open: (id?: string) => void): void;
+export declare function restartDaemon(api: TuiPluginApi, store: ShellStore): void;
+export declare function pickShell(api: TuiPluginApi, store: ShellStore, open: (id?: string) => void): void;

package/types/tui/index.d.ts

@@ -1,14 +1,8 @@
 /** @jsxImportSource @opentui/solid */
 import { type TuiPlugin, type TuiPluginModule } from "@opencode-ai/plugin/tui";
-export interface ShellTuiOptions {
-    dockHeight?: number;
-    /** Shell rows the sidebar shows before folding the rest away (default 5). */
-    sidebarRows?: number;
-    /** Failures stay visible this long after they end (default 30). */
-    historyMinutes?: number;
-    dockOpen?: boolean;
-    keybinds?: Record<string, string>;
-}
+import { type CockpitConfig } from "../core/config.ts";
+/** Interface settings; the `ui` section of the config file (see core/config.ts). */
+export type ShellTuiOptions = NonNullable<CockpitConfig["ui"]>;
 /** Shell's TUI half as a factory, so bundles such as `opencode-cockpit` can include it. */
 export declare function createShellTui({ source }?: {
     source?: string;

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

@@ -0,0 +1,3 @@
+import type { ShellInfo } from "@opencode-cockpit/protocol/shell";
+/** Everything known about one shell, for the console's details view. */
+export declare function detailRows(s: ShellInfo, now: number, cols: number): [string, string][];

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

@@ -0,0 +1,7 @@
+/** Log search helpers: what matched, and how failures should read. */
+export declare function splitMatches(text: string, query: string): {
+    text: string;
+    match: boolean;
+}[];
+/** Daemon errors name ids and internal states; say what happened instead. */
+export declare function friendlyError(err: unknown): string;

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

@@ -0,0 +1,25 @@
+/**
+ * Update notice.
+ *
+ * OpenCode resolves an unpinned plugin spec (`@latest`) once and then reuses its cached copy, so
+ * an install never moves forward on its own. The plugin therefore checks the registry itself, at
+ * most once a day, and offers to clear its own cache entry so the next start installs the newer
+ * version.
+ */
+export interface UpdateState {
+    /** Version currently running. */
+    current: string;
+    /** Newest version on the registry. */
+    latest: string;
+    /** Cache entry to remove so OpenCode reinstalls, when this is an npm install. */
+    cacheDir?: string;
+}
+export declare function shouldCheck(lastCheckedAt: number | undefined, now: number, everyMs?: number): boolean;
+/** True when `latest` is a higher release than `current`. Pre-releases never look newer. */
+export declare function isNewer(latest: string, current: string): boolean;
+/**
+ * The directory OpenCode installed this plugin into, given the resolved module path. Removing it
+ * makes the next start reinstall from the registry. Undefined for anything but an npm install.
+ */
+export declare function cacheDirFor(target: string | undefined, source: string): string | undefined;
+export declare function fetchLatestVersion(pkg: string, timeoutMs?: number): Promise<string | undefined>;

package/types/tui/{view.d.ts → lib/view.d.ts}

@@ -1,5 +1,5 @@
 import type { TuiThemeCurrent } from "@opencode-ai/plugin/tui";
-import type { ShellInfo } from "@opencode-cockpit/protocol/shell";
+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;
@@ -48,10 +48,21 @@ export declare function partition(list: readonly ShellInfo[], opts: PartitionOpt
             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". */
@@ -62,6 +73,8 @@ export declare function displayCommand(s: ShellInfo): string;
 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/{store.d.ts → state/store.d.ts}

@@ -41,6 +41,15 @@ export declare function useScreen(store: ShellStore, id: Accessor<string | undef
             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;
 };