@opencode-cockpit/shell 0.1.4 → 0.2.0

package/dist/tui/index.js

@@ -0,0 +1,205 @@
+import { memo as _$memo } from "@opentui/solid";
+import { createComponent as _$createComponent } from "@opentui/solid";
+/** @jsxImportSource @opentui/solid */
+
+import { createBindingLookup } from "@opencode-ai/plugin/tui";
+import { claimFeature, duplicateFeatureMessage } from "@opencode-cockpit/client";
+import { createSignal } from "solid-js";
+import pkg from "../../package.json" with { type: "json" };
+import { createClient } from "../connect.js";
+import { loadConfig } from "../core/config.js";
+import { Console } from "./components/console.js";
+import { Dock } from "./components/dock.js";
+import { SidebarShells } from "./components/sidebar.js";
+import { announceUpdate, newShell, offerUpdate, pickShell, restartDaemon } from "./dialogs.js";
+import { createShellStore } from "./state/store.js";
+const DEFAULT_KEYS = {
+  "cockpit.shells.dock": "<leader>o",
+  "cockpit.shells.console": "<leader>i"
+};
+
+/** Interface settings; the `ui` section of the config file (see core/config.ts). */
+
+const SHELL_PACKAGE = "@opencode-cockpit/shell";
+const _PACKAGE_NAME = pkg.name;
+
+/** Shell's TUI half as a factory, so bundles such as `opencode-cockpit` can include it. */
+export function createShellTui({
+  source = SHELL_PACKAGE
+} = {}) {
+  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 = async (api, rawOptions, meta) => {
+  // Settings come from the shared config file; plugin-entry options still win, flat or under "ui".
+  const config = loadConfig(api.state.path.directory, rawOptions);
+  const options = config.ui ?? {};
+  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(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 => {
+    const bindings = api.keymap.getCommandBindings({
+      visibility: "registered",
+      commands: [command]
+    });
+    return api.keys.formatBindings(bindings.get(command)) ?? "";
+  };
+  const openConsole = (id, typing = false) => {
+    if (id) store.select(id);
+    api.ui.dialog.replace(() => _$createComponent(Console, {
+      api: api,
+      store: store,
+      typing: typing,
+      get colors() {
+        return options.colors;
+      },
+      get defaultView() {
+        return options.defaultView;
+      },
+      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.update",
+      title: "Update opencode-cockpit",
+      category: "Shells",
+      namespace: "palette",
+      slashName: "cockpit-update",
+      run: () => offerUpdate(api, meta, pkg.version)
+    }, {
+      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 _$memo(() => _$memo(() => !!dockOpen())() ? _$createComponent(Dock, {
+          api: api,
+          store: store,
+          get height() {
+            return height();
+          },
+          get colors() {
+            return options.colors;
+          },
+          hint: () => `${shortcut("cockpit.shells.console")} console · ${shortcut("cockpit.shells.dock")} hide`,
+          onOpenConsole: id => openConsole(id)
+        }) : null);
+      },
+      sidebar_content() {
+        return _$createComponent(SidebarShells, {
+          api: api,
+          store: store,
+          get rows() {
+            return options.sidebarRows;
+          },
+          onOpen: id => openConsole(id),
+          consoleShortcut: () => shortcut("cockpit.shells.console")
+        });
+      }
+    }
+  });
+
+  // OpenCode never re-resolves an installed plugin spec, so check for a newer release ourselves.
+  if (options.updateCheck !== false) void announceUpdate(api, meta, pkg.version);
+
+  // 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();
+  });
+};
+const plugin = {
+  id: "opencode-cockpit.shell",
+  tui: createShellTui()
+};
+export default plugin;

package/dist/tui/lib/details.js

@@ -0,0 +1,23 @@
+import { kindOfShell } from "../../core/kind.js";
+import { displayCommand, statusDetail, truncate, wrapText } from "./view.js";
+
+/** Everything known about one shell, for the console's details view. */
+export function detailRows(s, now, cols) {
+  const width = Math.max(10, cols - 11);
+  const rows = [];
+  for (const [i, line] of wrapText(displayCommand(s), width, 12).entries()) rows.push([i === 0 ? "command" : "", line]);
+  rows.push(["kind", kindOfShell(s)]);
+  rows.push(["folder", s.cwd]);
+  rows.push(["status", `${s.status}${s.exitCode !== undefined ? ` (exit ${s.exitCode})` : ""}${s.signal ? ` (${s.signal})` : ""}`]);
+  rows.push(["timing", statusDetail(s, now)]);
+  rows.push(["started", new Date(s.startedAt).toLocaleString()]);
+  if (s.summary) rows.push(["summary", truncate(s.summary, width)]);
+  rows.push(["id", `${s.id} · run ${s.run}${s.pid ? ` · pid ${s.pid}` : ""}`]);
+  rows.push(["owner", s.owner.session ? `agent session ${s.owner.session}` : "you"]);
+  if (s.watch) {
+    rows.push(["watch", `${s.watch.preset ?? "custom rule"} · ${s.watch.status} · ${s.watch.runs} run${s.watch.runs === 1 ? "" : "s"}${s.watch.summary ? ` · ${truncate(s.watch.summary, width - 30)}` : ""}`]);
+  }
+  rows.push(["output", `${s.lines.last} lines · ${Math.round(s.bytes / 1024)} KiB`]);
+  if (s.logFile) rows.push(["log file", s.logFile]);
+  return rows;
+}

package/dist/tui/lib/keys.js

@@ -0,0 +1,43 @@
+const NAMED = {
+  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) {
+  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) {
+  return e.ctrl && (e.name === "]" || e.sequence === "\x1d");
+}

package/dist/tui/lib/search.js

@@ -0,0 +1,39 @@
+/** Log search helpers: what matched, and how failures should read. */
+export function splitMatches(text, query) {
+  if (!query) return [{
+    text,
+    match: false
+  }];
+  const parts = [];
+  const haystack = text.toLowerCase();
+  const needle = query.toLowerCase();
+  let from = 0;
+  for (let at = haystack.indexOf(needle, from); at !== -1; at = haystack.indexOf(needle, from)) {
+    if (at > from) parts.push({
+      text: text.slice(from, at),
+      match: false
+    });
+    parts.push({
+      text: text.slice(at, at + needle.length),
+      match: true
+    });
+    from = at + needle.length;
+  }
+  if (from < text.length) parts.push({
+    text: text.slice(from),
+    match: false
+  });
+  return parts.length > 0 ? parts : [{
+    text,
+    match: false
+  }];
+}
+
+/** Daemon errors name ids and internal states; say what happened instead. */
+export function friendlyError(err) {
+  const message = err instanceof Error ? err.message : String(err);
+  if (/is (exited|killed|failed)$/.test(message)) return "the shell is no longer running";
+  if (/not found$/.test(message)) return "that shell was already removed";
+  if (/connection|not running|did not start/.test(message)) return "lost connection to cockpitd, retrying";
+  return message;
+}

package/dist/tui/lib/update.js

@@ -0,0 +1,58 @@
+/**
+ * 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.
+ */
+
+const DAY_MS = 24 * 60 * 60 * 1000;
+export function shouldCheck(lastCheckedAt, now, everyMs = DAY_MS) {
+  return lastCheckedAt === undefined || now - lastCheckedAt >= everyMs;
+}
+
+/** True when `latest` is a higher release than `current`. Pre-releases never look newer. */
+export function isNewer(latest, current) {
+  const parse = v => {
+    const match = /^(\d+)\.(\d+)\.(\d+)(?:-([\w.]+))?$/.exec(v.trim());
+    return match ? {
+      nums: [Number(match[1]), Number(match[2]), Number(match[3])],
+      pre: match[4]
+    } : undefined;
+  };
+  const a = parse(latest);
+  const b = parse(current);
+  if (!a || !b) return false;
+  for (let i = 0; i < 3; i++) {
+    const diff = a.nums[i] - b.nums[i];
+    if (diff !== 0) return diff > 0;
+  }
+  // Same numbers: a release beats the pre-release of that version, never the other way round.
+  return a.pre === undefined && b.pre !== undefined;
+}
+
+/**
+ * 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 function cacheDirFor(target, source) {
+  if (source !== "npm" || !target) return undefined;
+  const [dir] = target.split(`${"/"}node_modules${"/"}`);
+  return dir && dir !== target ? dir : undefined;
+}
+export async function fetchLatestVersion(pkg, timeoutMs = 3000) {
+  try {
+    const response = await fetch(`https://registry.npmjs.org/${pkg}/latest`, {
+      signal: AbortSignal.timeout(timeoutMs),
+      headers: {
+        accept: "application/vnd.npm.install-v1+json"
+      }
+    });
+    if (!response.ok) return undefined;
+    const body = await response.json();
+    return body.version;
+  } catch {
+    return undefined; // offline, rate limited, private registry: never worth bothering the user
+  }
+}

package/dist/tui/lib/view.js

@@ -0,0 +1,191 @@
+import { duration } from "../../core/format.js";
+
+/** What a human cares about, derived from status + exit code so every surface agrees. */
+
+export function kindOf(s) {
+  if (s.status === "running") return "run";
+  if (s.status === "killed") return "stop";
+  if (s.status === "exited" && s.exitCode === 0) return "done";
+  return "fail";
+}
+export const BADGE_LABEL = {
+  run: "RUN",
+  fail: "FAIL",
+  stop: "STOP",
+  done: "DONE"
+};
+
+/** Braille spinner: single-width in every terminal font. */
+export const SPINNER = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+export function kindColor(theme, kind) {
+  switch (kind) {
+    case "run":
+      return theme.success;
+    case "fail":
+      return theme.error;
+    case "stop":
+      return theme.warning;
+    case "done":
+      return theme.textMuted;
+  }
+}
+
+/** Fixed 7-column pill so lists line up: " ⠹ RUN ", " FAIL  ". */
+export function badgeText(kind, frame = 0) {
+  if (kind === "run") return ` ${SPINNER[frame % SPINNER.length]} RUN `;
+  return ` ${BADGE_LABEL[kind].padEnd(4)}  `;
+}
+const RANK = {
+  run: 0,
+  fail: 1,
+  stop: 2,
+  done: 3
+};
+
+/** Running first (oldest first, stable tabs), then failures, stopped, done (most recent first). */
+export function order(list) {
+  return [...list].sort((a, b) => {
+    const ka = kindOf(a);
+    const kb = kindOf(b);
+    if (ka !== kb) return RANK[ka] - RANK[kb];
+    if (ka === "run") return a.startedAt - b.startedAt;
+    return (b.endedAt ?? b.startedAt) - (a.endedAt ?? a.startedAt);
+  });
+}
+/** Default view: running shells and recent failures. Everything else folds into a "N more" chip. */
+export function partition(list, opts) {
+  const ordered = order(list);
+  if (opts.showAll) return {
+    visible: ordered,
+    hidden: []
+  };
+  const visible = [];
+  const hidden = [];
+  for (const s of ordered) {
+    const kind = kindOf(s);
+    const recent = opts.now - (s.endedAt ?? opts.now) <= opts.historyMs;
+    if (kind === "run" || kind === "fail" && recent || s.id === opts.keep) visible.push(s);else hidden.push(s);
+  }
+  return {
+    visible,
+    hidden
+  };
+}
+export function statusDetail(s, now) {
+  const kind = kindOf(s);
+  const ran = duration((s.endedAt ?? now) - s.startedAt);
+  const ago = s.endedAt ? since(now - s.endedAt) : "";
+  switch (kind) {
+    case "run":
+      return ran;
+    case "done":
+      return `took ${ran} · ${ago}`;
+    case "stop":
+      return `stopped after ${ran} · ${ago}`;
+    case "fail":
+      if (s.status === "failed") return "could not start";
+      return `exit ${s.exitCode ?? "?"} after ${ran} · ${ago}`;
+  }
+}
+
+/** 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)) {
+    case "run":
+      return duration(now - s.startedAt);
+    case "fail":
+      return s.status === "failed" ? "no start" : `exit ${s.exitCode ?? "?"}`;
+    case "stop":
+      return "stopped";
+    case "done":
+      return s.endedAt ? since(now - s.endedAt) : "done";
+  }
+}
+
+/** Coarse relative time: "just now", "12s ago", "9m ago", "3h ago". */
+export function since(ms) {
+  const s = Math.floor(ms / 1000);
+  if (s < 5) return "just now";
+  if (s < 60) return `${s}s ago`;
+  if (s < 3600) return `${Math.floor(s / 60)}m ago`;
+  if (s < 86_400) return `${Math.floor(s / 3600)}h ago`;
+  return `${Math.floor(s / 86_400)}d ago`;
+}
+
+/** The command as the user or agent wrote it, without the `$SHELL -c` wrapper. */
+export function displayCommand(s) {
+  if (s.args.length === 2 && s.args[0] === "-c" && /(^|\/)(ba|z|fi|da|k)?sh$/.test(s.command)) return s.args[1];
+  return [s.command, ...s.args].join(" ");
+}
+
+/** Folder relative to the project: "" at the root, "./sub" inside, "~/x" elsewhere under home. */
+export function relativeCwd(cwd, project, home = process.env.HOME ?? "") {
+  const trim = p => p.replace(/\/+$/, "");
+  const c = trim(cwd);
+  const p = trim(project);
+  if (c === p) return "";
+  if (c.startsWith(`${p}/`)) return `./${c.slice(p.length + 1)}`;
+  if (home && c.startsWith(`${trim(home)}/`)) return `~/${c.slice(trim(home).length + 1)}`;
+  return c;
+}
+
+/** Hard-wraps to `width`, at most `maxLines`; the last line ends with … when text was cut. */
+export function wrapText(text, width, maxLines) {
+  const flat = text.replace(/\s*\n\s*/g, " ⏎ ");
+  const w = Math.max(4, width);
+  const lines = [];
+  for (let i = 0; i < flat.length && lines.length < maxLines; i += w) lines.push(flat.slice(i, i + w));
+  if (lines.length === 0) return [""];
+  if (flat.length > w * maxLines) {
+    const last = lines[lines.length - 1];
+    lines[lines.length - 1] = `${last.slice(0, w - 1)}…`;
+  }
+  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 "";
+  const lines = text.split("\n");
+  return lines.slice(Math.max(0, lines.length - rows)).map(l => l.length > cols ? `${l.slice(0, Math.max(0, cols - 1))}…` : l).join("\n");
+}
+export function truncate(text, max) {
+  return text.length > max ? `${text.slice(0, Math.max(0, max - 1))}…` : text;
+}