@opencode-cockpit/shell 0.1.4 → 0.2.0

package/dist/tui/state/store.js

@@ -0,0 +1,158 @@
+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 "../lib/view.js";
+export function createShellStore(api, client, options = {}) {
+  return createRoot(dispose => {
+    const [state, setState] = createStore({
+      list: []
+    });
+    const [connected, setConnected] = createSignal(false);
+    const [now, setNow] = createSignal(Date.now());
+    const [frame, setFrame] = createSignal(0);
+    const [selectedId, setSelectedId] = createSignal();
+    const [showAll, setShowAll] = createSignal(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),
+      // 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 = 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];
+        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, id) {
+  const [screen, setScreen] = createSignal();
+  let timer;
+  let current;
+  const fetch = shellId => {
+    timer = undefined;
+    void store.client.call("shell.screen", {
+      id: shellId
+    }).then(s => {
+      if (current === shellId) setScreen(s);
+    }).catch(() => {});
+  };
+  const schedule = shellId => {
+    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 => {
+    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)
+  };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opencode-cockpit/shell",
-  "version": "0.1.4",
+  "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",
@@ -24,16 +24,26 @@
     "terminal"
   ],
   "exports": {
-    "./server": "./src/server.ts",
-    "./tui": "./src/tui/index.tsx",
-    "./connect": "./src/connect.ts"
+    "./server": {
+      "types": "./types/server.d.ts",
+      "default": "./dist/server.js"
+    },
+    "./tui": {
+      "types": "./types/tui/index.d.ts",
+      "default": "./dist/tui/index.js"
+    },
+    "./connect": {
+      "types": "./types/connect.d.ts",
+      "default": "./dist/connect.js"
+    }
   },
   "engines": {
     "opencode": ">=1.18.0",
     "bun": ">=1.3.5"
   },
   "files": [
-    "src",
+    "dist",
+    "types",
     "README.md",
     "LICENSE"
   ],
@@ -41,16 +51,15 @@
     "access": "public"
   },
   "dependencies": {
-    "@opencode-cockpit/client": "0.1.4",
-    "@opencode-cockpit/daemon": "0.1.4",
-    "@opencode-cockpit/protocol": "0.1.4",
-    "@opencode-ai/plugin": "1.18.31",
+    "@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": {
     "@opentui/core": "0.4.5",
     "@opentui/keymap": "0.4.5",
     "@opentui/solid": "0.4.5",
     "solid-js": "1.9.12"
-  },
-  "devDependencies": {
-    "zod": "4.6.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/keys.d.ts

@@ -0,0 +1,3 @@
+/** Translates named keys (`enter`, `ctrl+c`, `up`) into the bytes a terminal would send. */
+export declare function encodeKey(name: string): string;
+export declare const KEY_NAMES: string[];

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/connect.d.ts

@@ -0,0 +1,9 @@
+import { CockpitClient } from "@opencode-cockpit/client";
+/** Resolves the daemon entry shipped with this package. */
+export declare function daemonEntry(): string;
+/**
+ * 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 declare function createClient(name: string): CockpitClient;

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/core/find.d.ts

@@ -0,0 +1,37 @@
+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[];
+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 declare function matchByName(list: readonly ShellInfo[], name: string): NameMatch;

package/types/core/format.d.ts

@@ -0,0 +1,8 @@
+import type { LogLine, ReadResult, ShellInfo, WaitResult } from "@opencode-cockpit/protocol/shell";
+/** Compact log lines for a model: numbered, long lines cut, consecutive repeats collapsed. */
+export declare function formatLines(lines: LogLine[]): string;
+export declare function describeStatus(info: ShellInfo): string;
+export declare function header(info: ShellInfo): string;
+export declare function formatRead(info: ShellInfo, page: ReadResult, empty?: string): string;
+export declare function formatWait(result: WaitResult, timeoutSeconds: number): string;
+export declare function duration(ms: number): string;

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

@@ -0,0 +1,2 @@
+/** Published entry point: `@opencode-cockpit/shell/server`. */
+export { createShellServer, default, SHELL_PACKAGE, type ShellServerOptions } from "./agent/plugin.ts";

package/types/tui/components/badge.d.ts

@@ -0,0 +1,9 @@
+/** @jsxImportSource @opentui/solid */
+import type { TuiPluginApi } from "@opencode-ai/plugin/tui";
+import type { ShellInfo } from "@opencode-cockpit/protocol/shell";
+/** Status pill: label on a coloured background, readable in any font and colour scheme. */
+export declare function Badge(props: {
+    api: TuiPluginApi;
+    shell: ShellInfo;
+    frame: number;
+}): import("solid-js").JSX.Element;

package/types/tui/components/console.d.ts

@@ -0,0 +1,22 @@
+/** @jsxImportSource @opentui/solid */
+import type { TuiPluginApi } from "@opencode-ai/plugin/tui";
+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/components/dock.d.ts

@@ -0,0 +1,14 @@
+/** @jsxImportSource @opentui/solid */
+import type { TuiPluginApi } from "@opencode-ai/plugin/tui";
+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;
+}
+/** Split pane under the chat: status tabs for shells and the selected shell's live screen. */
+export declare function Dock(props: DockProps): import("solid-js").JSX.Element;

package/types/tui/components/sidebar.d.ts

@@ -0,0 +1,14 @@
+/** @jsxImportSource @opentui/solid */
+import type { TuiPluginApi } from "@opencode-ai/plugin/tui";
+import type { ShellStore } from "../state/store.ts";
+export interface SidebarProps {
+    api: TuiPluginApi;
+    store: ShellStore;
+    /** Rows shown before the rest folds away; the sidebar is a narrow, shared column. */
+    rows?: number;
+    /** Rows shown while expanded, so a hundred shells can never push the sidebar over. */
+    expandedRows?: number;
+    onOpen: (id: string) => void;
+    consoleShortcut: () => string;
+}
+export declare function SidebarShells(props: SidebarProps): import("solid-js").JSX.Element;

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

@@ -0,0 +1,13 @@
+/** @jsxImportSource @opentui/solid */
+import { type TuiPlugin, type TuiPluginModule } from "@opencode-ai/plugin/tui";
+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;
+}): TuiPlugin;
+declare const plugin: TuiPluginModule & {
+    id: string;
+};
+export default plugin;

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/keys.d.ts

@@ -0,0 +1,8 @@
+import type { KeyEvent } from "@opentui/core";
+/**
+ * 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 declare function keyToBytes(e: KeyEvent): string | undefined;
+/** ctrl+] releases typing mode (the telnet escape), since esc and ctrl+c belong to the program. */
+export declare function isReleaseKey(e: KeyEvent): boolean;

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>;