@opencode-cockpit/shell 0.1.5 → 0.2.0

package/README.md

@@ -35,7 +35,8 @@ one loaded is used and OpenCode shows a warning.
 | `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` | Find shells: filter by text (`query`), `status` (running, failed, finished) and `session` (this, others). Each shows which session started it. |
+| `shell_list` | Find shells: filter by text (`query`), `status`, `session` and `kind` (server, tests, build, watcher, task — derived from the command). |
+| `shell_watch` | Watch a never-ending process and be told **only when its health changes**: "tsc: ok → 3 errors". |
 | `shell_stop` · `shell_restart` | Manage shells. |
 
 Every tool that acts on a shell takes its `id` **or its name** (the description it was started
@@ -43,12 +44,42 @@ with), so you can ask about shells naturally, including ones started in other se
 
 - *"How is DB Monitoring doing?"* → `shell_read name="DB Monitoring"`
 - *"Did any shell from my other session fail?"* → `shell_list status="failed" session="others"`
+- *"Which dev servers are up?"* → `shell_list kind="server" status="running"`
 
 Names match ignoring case, then partially on name or command. If a name fits several shells the
 agent gets the candidates instead of a guess.
 
 The agent is messaged when a shell it started exits on its own.
 
+### Watching health
+
+`tsc --watch` and friends never exit, so re-reading their logs is the only way to know how they are
+doing — and it costs tokens every time. A watcher reads the log instead and reports transitions:
+
+```
+shell_start command="tsc --watch --noEmit" description="type checker" watch=true
+→ watching health (tsc)
+
+… later, on its own:
+<shell_health id="sh_9wq2f1ab" title="type checker" status="fail">
+tsc: ok → fail
+src/auth.ts(42,3): error TS2339: Property 'id' does not exist on type 'User'.
+</shell_health>
+```
+
+Nothing is sent while a run keeps producing the same result, and a **watched process that dies is
+reported as a failure**, so a crashed dev server no longer goes unnoticed.
+
+A watch rule is three regexes, not a parser: `done` (a run ended), `fail` and `ok`. Presets ship for
+tsc, eslint, biome, prettier, mypy, ruff, vitest, jest, mocha, bun test, deno test, pytest, rspec,
+phpunit, playwright, cypress, vite, next, nuxt, astro, angular, webpack/rspack, esbuild, tsup,
+turbo, metro, storybook, cargo, go, dotnet, gradle, maven, docker compose and terraform. Anything
+else takes its own patterns:
+
+```
+shell_watch name="deploy" rule={ fail: "FAILED", ok: "SUCCEEDED", idleSeconds: 5 }
+```
+
 Things to ask:
 
 - *"Start the dev server in a background shell and wait until it's ready."*
@@ -63,34 +94,84 @@ Things to ask:
 | `ctrl+x i` · `/shell` | Open the shell console |
 | `/shell-new` | Start a shell yourself |
 | `/shells-clear` | Remove finished shells |
+| `/cockpit-update` | Update the plugin when a newer release exists |
 | `/shells-restart-daemon` | Restart `cockpitd` (asks first when shells are running) |
 
+Watched shells also show their health (`tsc ✓`, `vitest ✗`) in the panel, sidebar and console.
+
 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`.
 
-**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.
+**Console keys**, and only the ones that apply right now. 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, `/` search the log (`backspace` clears the filter),
+`?` details, `[` `]` switch shells, `D` clear finished, `esc` close.
+
+**Searching a long log.** In the console, `/` filters the scrollback to matching lines — keeping
+their original line numbers and highlighting the match — so a 40k-line dev server is one query away
+from the five lines you want. Filtering happens in the daemon, not the terminal.
+
+**Output keeps its colours.** The panel and console paint what the program actually printed, so
+`vitest`, `eslint` and friends read the way they do in a terminal.
 
 ## Configuration
 
-Options go on the plugin entry in `tui.json`:
+Everything is optional. Settings can live in a **config file**, which is read once and applies to
+both halves of the plugin — the agent's tools and the interface:
+
+```
+~/.config/opencode-cockpit/config.json   →   <project>/.cockpit.json   →   plugin-entry options
+```
+
+Later sources win key by key, so a project can override one setting without restating the rest. An
+unreadable or invalid file is ignored rather than fatal: a typo should never stop shells from
+working. (`XDG_CONFIG_HOME` is honoured for the global path.)
+
+```json
+{
+  "kinds": { "e2e": "playwright|cypress", "infra": "^(terraform|pulumi)\\b" },
+  "watch": {
+    "auto": false,
+    "presets": { "e2e": { "done": "\\d+ passed", "fail": "\\d+ failed", "ignoreCase": true } }
+  },
+  "defaults": { "logFile": true, "timeoutSeconds": 900 },
+  "notify": { "exit": true, "watch": true, "tailLines": 15 },
+  "guidance": true,
+  "listRunningShells": 15,
+  "ui": { "dockHeight": 16, "dockOpen": true, "historyMinutes": 60, "colors": true }
+}
+```
+
+| Section | Meaning |
+|---|---|
+| `kinds` | Extra shell categories, or overrides, as name → regex matched against the command. Drives the badges in the sidebar, panel and `shell_list`, so you can group your own stack (`e2e`, `infra`, `worker`) instead of the built-ins. |
+| `watch.presets` | Your own watch rules, or replacements for built-ins, keyed by name. A rule is `{ done?, fail?, ok?, idleSeconds?, ignoreCase? }` — patterns are regular expressions matched against each output line. The agent can then ask for `watch: "e2e"`. |
+| `watch.auto` | Attach a matching preset to every new shell without being asked. **Off by default**: watching is useful, but silently attaching rules to commands you didn't opt in surprises people. Turn it on once you trust your presets. |
+| `defaults` | Applied to every shell the agent starts unless the call says otherwise: `watch` (`true` for a matching preset, or a preset name), `logFile`, `idleTimeoutSeconds`, `timeoutSeconds`, `notifyOnExit`. |
+| `notify` | What may interrupt the agent — `exit`, `watch`, and `tailLines` (output lines included in an exit message). |
+| `guidance` | The system-prompt paragraph that teaches the agent when to use shells. `false` saves ~120 tokens per request, at the cost of a model that uses shells less well. |
+| `listRunningShells` | How many running shells are listed in the system prompt each turn (~20 tokens each). `0` disables it; the agent can still call `shell_list`. |
+| `ui` | Interface only: `dockHeight`, `dockOpen`, `sidebarRows`, `historyMinutes`, `colors`, `defaultView` (`"screen"` or `"log"`), `keybinds`, `updateCheck`. |
+
+The same settings can go on the plugin entry instead, which is handy for one-offs and for machines
+where you'd rather keep everything in `tui.json`/`opencode.json`:
 
 ```json
 {
   "plugin": [
     ["@opencode-cockpit/shell", {
-      "dockHeight": 16,
-      "dockOpen": true,
-      "historyMinutes": 60,
+      "ui": { "dockHeight": 16 },
       "keybinds": { "cockpit.shells.dock": "<leader>j", "cockpit.shells.console": "<leader>k" }
     }]
   ]
 }
 ```
 
-Using `opencode-cockpit` instead? Put the same options under `"shell"`:
-`["opencode-cockpit", { "shell": { "dockHeight": 16 } }]`.
+`ui` keys also work spelled flat at the top level (`{ "dockHeight": 16 }`), as they did before the
+config file existed. Using `opencode-cockpit` instead of the standalone package? Put the same
+object under `"shell"`: `["opencode-cockpit", { "shell": { "ui": { "dockHeight": 16 } } }]`.
+Interface settings must be reachable from `tui.json`, agent settings from `opencode.json` — which
+is exactly why the config file exists.
 
 | Environment variable | Default | Purpose |
 |---|---|---|
@@ -98,6 +179,15 @@ Using `opencode-cockpit` instead? Put the same options under `"shell"`:
 | `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 |
 
+**Limits and log files** (per shell, set by the agent, or by `defaults` above):
+
+- `timeoutSeconds` — stop it after this long, busy or not. Good for probes: *"watch the DB for two
+  minutes"*.
+- `idleTimeoutSeconds` — stop it after this much silence. Never use it for dev servers, which are
+  idle when healthy.
+- `logFile` — also write the clean log to `~/.cache/opencode-cockpit/logs/<id>.log`, so history
+  survives the in-memory buffer. The path shows in the console's details view.
+
 ## Troubleshooting
 
 | Problem | Look at |

package/dist/agent/plugin.js

@@ -0,0 +1,180 @@
+import { claimFeature, duplicateFeatureMessage } from "@opencode-cockpit/client";
+import { createClient } from "../connect.js";
+import { loadConfig } from "../core/config.js";
+import { describeStatus, formatLines } from "../core/format.js";
+import { createTools } from "./tools/index.js";
+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.
+For processes that never exit (tsc --watch, vitest --watch, dev servers), shell_watch reports only when their health changes — use it instead of re-reading their logs.`;
+export const SHELL_PACKAGE = "@opencode-cockpit/shell";
+/** Shell's server half as a factory, so bundles such as `opencode-cockpit` can include it. */
+export function createShellServer({
+  source = SHELL_PACKAGE
+} = {}) {
+  return async (input, options) => {
+    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, options);
+    const dispose = hooks.dispose;
+    return {
+      ...hooks,
+      dispose: async () => {
+        claim.release();
+        await dispose?.();
+      }
+    };
+  };
+}
+async function shellHooks({
+  client: opencode,
+  directory
+}, options) {
+  const config = loadConfig(directory, options);
+  const cockpit = createClient("opencode-cockpit/server");
+  const instance = crypto.randomUUID();
+  const quiet = new Set();
+  const userShell = process.env.SHELL && /(bash|zsh|fish|sh)$/.test(process.env.SHELL) ? process.env.SHELL : "/bin/bash";
+  const env = () => {
+    const out = {};
+    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();
+  const sessionTitle = async sessionID => {
+    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?.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) || config.notify?.exit === false) return;
+    void notifyExit(info).catch(() => {});
+  });
+
+  // A watcher's health changed. This is the whole point of watching: one message per change, never
+  // per line, so a thousand identical recompiles cost nothing.
+  cockpit.on("shell.watch", event => {
+    const info = event.info;
+    if (config.notify?.watch === false) return;
+    if (info.owner.instance !== instance || !info.owner.session || event.current === "pending") return;
+    const text = [`<shell_health id="${info.id}" title="${info.title}" status="${event.current}">`, `${info.watch?.preset ?? "watch"}: ${event.previous} → ${event.current}`, event.summary ?? "", "</shell_health>", event.current === "ok" ? "Previously reported problems in this shell are resolved." : `Investigate with shell_read id=${info.id} if this affects your current task.`].filter(Boolean).join("\n");
+    void opencode.session.promptAsync({
+      path: {
+        id: info.owner.session
+      },
+      body: {
+        parts: [{
+          type: "text",
+          text,
+          synthetic: true
+        }]
+      }
+    }).catch(() => {});
+  });
+  async function notifyExit(info) {
+    const session = info.owner.session;
+    const page = await cockpit.call("shell.read", {
+      id: info.id,
+      tail: config.notify?.tailLines ?? 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
+        }]
+      }
+    });
+  }
+  return {
+    tool: createTools({
+      client: cockpit,
+      instance,
+      quiet,
+      env,
+      config,
+      sessionTitle,
+      shellCommand: command => ({
+        command: userShell,
+        args: ["-c", command]
+      })
+    }),
+    "experimental.chat.system.transform": async (input, output) => {
+      if (config.guidance !== false) output.system.push(GUIDANCE);
+      const listLimit = config.listRunningShells ?? 15;
+      if (listLimit <= 0) return;
+      const running = await cockpit.call("shell.list", {
+        owner: {
+          project: directory
+        },
+        includeExited: false
+      }).catch(() => []);
+      if (running.length > 0) {
+        output.system.push(`Background shells currently running in this project:\n${running.slice(0, listLimit).map(s => {
+          const from = !s.owner.session ? ", started by the user" : s.owner.session === input.sessionID ? "" : ", another session";
+          const health = s.watch ? `, ${s.watch.preset ?? "watch"}: ${s.watch.status}` : "";
+          return `- ${s.id} "${s.title}" (${describeStatus(s)}${from}${health})`;
+        }).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(() => []);
+      for (const shell of owned) {
+        quiet.add(shell.id);
+        await cockpit.call("shell.remove", {
+          id: shell.id
+        }).catch(() => {});
+      }
+    },
+    dispose: async () => {
+      cockpit.close();
+    }
+  };
+}
+const plugin = {
+  id: "opencode-cockpit.shell",
+  server: createShellServer()
+};
+export default plugin;

package/dist/agent/tools/index.js

@@ -0,0 +1,23 @@
+import { shellList } from "./list.js";
+import { shellRead } from "./read.js";
+import { shellRestart } from "./restart.js";
+import { shellSend } from "./send.js";
+import { createToolKit } from "./shared.js";
+import { shellStart } from "./start.js";
+import { shellStop } from "./stop.js";
+import { shellWait } from "./wait.js";
+import { shellWatch } from "./watch.js";
+/** The shell tools an agent sees. One file per tool; `shared.ts` holds what they have in common. */
+export function createTools(deps) {
+  const kit = createToolKit(deps);
+  return {
+    shell_start: shellStart(kit),
+    shell_read: shellRead(kit),
+    shell_send: shellSend(kit),
+    shell_wait: shellWait(kit),
+    shell_watch: shellWatch(kit),
+    shell_list: shellList(kit),
+    shell_stop: shellStop(kit),
+    shell_restart: shellRestart(kit)
+  };
+}

package/dist/agent/tools/list.js

@@ -0,0 +1,68 @@
+import { tool } from "@opencode-ai/plugin";
+import { commandOf, filterShells } from "../../core/find.js";
+import { describeStatus } from "../../core/format.js";
+import { kindOfShell } from "../../core/kind.js";
+const z = tool.schema;
+/**
+ * Every per-shell tool takes an id or a name. Declared per tool file because exported zod schemas
+ * cannot be named portably in generated declarations.
+ */
+const _TARGET = {
+  id: z.string().optional().describe("Shell id from shell_start or shell_list, e.g. sh_ab12cd34"),
+  name: z.string().optional().describe('Instead of id: the shell\'s name (the description it was started with), e.g. "DB Monitoring". Partial names and command text also match.')
+};
+export function shellList(kit) {
+  const {
+    client,
+    config,
+    sessionLabel
+  } = kit;
+  // Kinds from config are filterable too, or classifying a command as "e2e" would be a dead end.
+  const kinds = ["server", "tests", "build", "watcher", "task", ...Object.keys(config.kinds ?? {})];
+  const kindValues = ["any", ...kinds];
+  return tool({
+    description: `List background shells in this project: name, status, which session started it, and the last output line.
+
+  Filter to find the one you need instead of reading them all:
+  - query: text in the name or command, e.g. "db" or "vitest"
+  - status: running, failed, finished
+  - session: this (started by you in this session), others (other sessions or the user)
+  - kind: ${kinds.join(", ")} — derived from the command, so "which servers are up?" is one call`,
+    args: {
+      query: z.string().optional().describe("Case-insensitive text in the shell name or command"),
+      status: z.enum(["running", "failed", "finished", "any"]).default("any"),
+      session: z.enum(["this", "others", "any"]).default("any"),
+      kind: z.enum(kindValues).default("any").describe("What the shell is, derived from its command"),
+      all: z.boolean().default(false).describe("Include shells from other projects")
+    },
+    async execute(args, ctx) {
+      const everything = await client.call("shell.list", args.all === true ? {} : {
+        owner: {
+          project: ctx.directory
+        }
+      });
+      const shells = filterShells(everything, {
+        kind: args.kind ?? "any",
+        kinds: config.kinds,
+        query: args.query ?? undefined,
+        status: args.status ?? "any",
+        session: args.session ?? "any",
+        currentSession: ctx.sessionID
+      });
+      if (everything.length === 0) return "No background shells.";
+      if (shells.length === 0) return `No shells match those filters (${everything.length} shell${everything.length === 1 ? "" : "s"} in total).`;
+      const rows = await Promise.all(shells.map(async s => {
+        const last = await client.call("shell.read", {
+          id: s.id,
+          tail: 1
+        }).catch(() => undefined);
+        const tail = last?.lines[0]?.text ?? "";
+        const failure = s.summary && s.status !== "running" ? `\n    summary: ${s.summary.slice(0, 200)}` : "";
+        const watch = s.watch ? `\n    watch: ${s.watch.preset ?? "custom"} · ${s.watch.status}${s.watch.summary ? ` · ${s.watch.summary.slice(0, 120)}` : ""}` : "";
+        return [`${s.id}  ${s.status.padEnd(7)}  "${s.title}"${s.run > 1 ? ` (run ${s.run})` : ""} · ${kindOfShell(s, config.kinds)} · ${await sessionLabel(s, ctx)}`, `    $ ${commandOf(s).slice(0, 200)}${failure}`, `    ${describeStatus(s)}${watch}${tail ? `\n    last: ${tail.slice(0, 200)}` : ""}`].join("\n");
+      }));
+      const hidden = everything.length - shells.length;
+      return rows.join("\n") + (hidden > 0 ? `\n(${hidden} more shell${hidden === 1 ? "" : "s"} hidden by filters)` : "");
+    }
+  });
+}

package/dist/agent/tools/read.js

@@ -0,0 +1,59 @@
+import { tool } from "@opencode-ai/plugin";
+import { describeStatus, formatRead, header } from "../../core/format.js";
+const READ = `Read a background shell's output.
+
+- Default: the last lines of the log (colours removed, progress-bar redraws collapsed).
+- after=<cursor>: only lines newer than a cursor returned by a previous call. Use this to follow output.
+- grep=<regex>: only matching lines (e.g. "error|warn").
+- view="screen": what the terminal shows right now. Use for full-screen programs (htop, vitest UI, prompts that redraw).`;
+const z = tool.schema;
+/**
+ * Every per-shell tool takes an id or a name. Declared per tool file because exported zod schemas
+ * cannot be named portably in generated declarations.
+ */
+const TARGET = {
+  id: z.string().optional().describe("Shell id from shell_start or shell_list, e.g. sh_ab12cd34"),
+  name: z.string().optional().describe('Instead of id: the shell\'s name (the description it was started with), e.g. "DB Monitoring". Partial names and command text also match.')
+};
+export function shellRead(kit) {
+  const {
+    client,
+    resolve
+  } = kit;
+  return tool({
+    description: READ,
+    args: {
+      ...TARGET,
+      view: z.enum(["log", "screen"]).default("log"),
+      after: z.number().int().min(0).optional().describe("Cursor from a previous result; returns only newer lines"),
+      tail: z.number().int().positive().max(2000).default(60).describe("Lines from the end when no cursor is given"),
+      grep: z.string().optional().describe("Regex filter"),
+      ignoreCase: z.boolean().default(false),
+      limit: z.number().int().positive().max(2000).default(300)
+    },
+    async execute(args, ctx) {
+      const {
+        id,
+        note
+      } = await resolve(args, ctx);
+      const info = await client.call("shell.get", {
+        id
+      });
+      if (args.view === "screen") {
+        const screen = await client.call("shell.screen", {
+          id
+        });
+        return [`${note}${header(info)}`, `status: ${describeStatus(info)}`, `screen ${screen.cols}x${screen.rows}:`, screen.text || "(blank)", "</shell>"].join("\n");
+      }
+      const page = await client.call("shell.read", {
+        id,
+        after: args.after ?? undefined,
+        tail: args.tail ?? 60,
+        grep: args.grep ?? undefined,
+        ignoreCase: args.ignoreCase ?? false,
+        limit: args.limit ?? 300
+      });
+      return note + formatRead(info, page, args.after != null ? "(no new output)" : "(no output yet)");
+    }
+  });
+}

package/dist/agent/tools/restart.js

@@ -0,0 +1,44 @@
+import { tool } from "@opencode-ai/plugin";
+import { abortable } from "./shared.js";
+const z = tool.schema;
+/**
+ * Every per-shell tool takes an id or a name. Declared per tool file because exported zod schemas
+ * cannot be named portably in generated declarations.
+ */
+const TARGET = {
+  id: z.string().optional().describe("Shell id from shell_start or shell_list, e.g. sh_ab12cd34"),
+  name: z.string().optional().describe('Instead of id: the shell\'s name (the description it was started with), e.g. "DB Monitoring". Partial names and command text also match.')
+};
+export function shellRestart(kit) {
+  const {
+    client,
+    deps,
+    peek,
+    resolve
+  } = kit;
+  return tool({
+    description: "Restart a background shell with the same command. Keeps the id; output continues after a restart marker.",
+    args: {
+      ...TARGET
+    },
+    async execute(args, ctx) {
+      const {
+        id,
+        note
+      } = await resolve(args, ctx);
+      const info = await client.call("shell.restart", {
+        id
+      });
+      deps.quiet.delete(id);
+      await abortable(ctx, client.call("shell.wait", {
+        id: info.id,
+        until: {
+          idleMs: 700,
+          exit: true
+        },
+        timeoutMs: 2500
+      }));
+      return `${note}Restarted ${info.id} (run ${info.run})\n${await peek(info)}`;
+    }
+  });
+}

package/dist/agent/tools/send.js

@@ -0,0 +1,71 @@
+import { tool } from "@opencode-ai/plugin";
+import { formatRead } from "../../core/format.js";
+import { encodeKey, KEY_NAMES } from "./keys.js";
+import { abortable } from "./shared.js";
+const SEND = `Send input to a running background shell, then return the output it produced.
+
+- text: literal characters. Set submit=true to press enter afterwards.
+- keys: named keys pressed in order, e.g. ["ctrl+c"], ["down", "enter"]. Supported: ${KEY_NAMES.join(", ")}.`;
+const z = tool.schema;
+/**
+ * Every per-shell tool takes an id or a name. Declared per tool file because exported zod schemas
+ * cannot be named portably in generated declarations.
+ */
+const TARGET = {
+  id: z.string().optional().describe("Shell id from shell_start or shell_list, e.g. sh_ab12cd34"),
+  name: z.string().optional().describe('Instead of id: the shell\'s name (the description it was started with), e.g. "DB Monitoring". Partial names and command text also match.')
+};
+export function shellSend(kit) {
+  const {
+    client,
+    resolve
+  } = kit;
+  return tool({
+    description: SEND,
+    args: {
+      ...TARGET,
+      text: z.string().optional(),
+      keys: z.array(z.string()).optional(),
+      submit: z.boolean().default(false).describe("Press enter after text"),
+      waitSeconds: z.number().min(0).max(30).default(1).describe("Max time to collect the response")
+    },
+    async execute(args, ctx) {
+      if (!args.text && !args.keys?.length) throw new Error("provide text and/or keys");
+      let data = args.text ?? "";
+      for (const key of args.keys ?? []) data += encodeKey(key);
+      if (args.submit === true) data += "\r";
+      const {
+        id,
+        note
+      } = await resolve(args, ctx);
+      const before = await client.call("shell.get", {
+        id
+      });
+      await client.call("shell.write", {
+        id,
+        data
+      });
+      const waitSeconds = args.waitSeconds ?? 1;
+      if (waitSeconds > 0) {
+        await abortable(ctx, client.call("shell.wait", {
+          id,
+          until: {
+            idleMs: 400,
+            exit: true
+          },
+          timeoutMs: Math.round(waitSeconds * 1000),
+          after: before.lines.last
+        }));
+      }
+      const info = await client.call("shell.get", {
+        id
+      });
+      const page = await client.call("shell.read", {
+        id,
+        after: before.lines.last,
+        limit: 300
+      });
+      return note + formatRead(info, page, "(no new output lines; if this is a full-screen program use shell_read view=screen)");
+    }
+  });
+}