@opencode-cockpit/shell 0.1.4 → 0.1.5

package/dist/connect.js

@@ -0,0 +1,31 @@
+import { fileURLToPath } from "node:url";
+import { CockpitClient } from "@opencode-cockpit/client";
+import daemonPkg from "@opencode-cockpit/daemon/package.json" with { type: "json" };
+import { daemonBuildId } from "@opencode-cockpit/protocol";
+import pkg from "../package.json" with { type: "json" };
+
+/** Resolves the daemon entry shipped with this package. */
+export function daemonEntry() {
+  return fileURLToPath(import.meta.resolve("@opencode-cockpit/daemon/main"));
+}
+
+/**
+ * Inside OpenCode `process.execPath` is the OpenCode binary; the client starts the daemon with
+ * BUN_BE_BUN=1 so it runs on OpenCode's embedded Bun (ADR 0001). The expected build lets the
+ * client replace a daemon left running from older plugin code.
+ */
+export function createClient(name) {
+  const entry = daemonEntry();
+  return new CockpitClient({
+    client: {
+      name,
+      version: pkg.version,
+      pid: process.pid
+    },
+    spawn: {
+      entry,
+      execPath: process.execPath
+    },
+    expectedBuild: daemonBuildId(entry, daemonPkg.version)
+  });
+}

package/dist/server.js

@@ -0,0 +1,152 @@
+import { claimFeature, duplicateFeatureMessage } from "@opencode-cockpit/client";
+import { createClient } from "./connect.js";
+import { describeStatus, formatLines } from "./tools/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.`;
+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 => {
+    const claim = claimFeature(input, "shell", source);
+    if (!claim.active) {
+      // Logging through the server during plugin initialisation could wait on ourselves; defer it.
+      setTimeout(() => {
+        void input.client.app.log({
+          body: {
+            service: "opencode-cockpit",
+            level: "warn",
+            message: duplicateFeatureMessage("Shell", claim.owner, source)
+          }
+        }).catch(() => {});
+      }, 0);
+      return {};
+    }
+    const hooks = await shellHooks(input);
+    const dispose = hooks.dispose;
+    return {
+      ...hooks,
+      dispose: async () => {
+        claim.release();
+        await dispose?.();
+      }
+    };
+  };
+}
+async function shellHooks({
+  client: opencode,
+  directory
+}) {
+  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)) return;
+    void notifyExit(info).catch(() => {});
+  });
+  async function notifyExit(info) {
+    const session = info.owner.session;
+    const page = await cockpit.call("shell.read", {
+      id: info.id,
+      tail: 15
+    });
+    const failed = info.status === "failed" || info.status === "exited" && info.exitCode !== 0 || info.status === "killed";
+    const text = [`<shell_exited id="${info.id}" title="${info.title}">`, describeStatus(info), page.lines.length > 0 ? `last output:\n${formatLines(page.lines)}` : "(no output)", "</shell_exited>", failed ? `Investigate with shell_read id=${info.id} grep="error|fail" if the failure matters to the task.` : `Full output: shell_read id=${info.id}.`].join("\n");
+    await opencode.session.promptAsync({
+      path: {
+        id: session
+      },
+      body: {
+        parts: [{
+          type: "text",
+          text,
+          synthetic: true
+        }]
+      }
+    });
+  }
+  return {
+    tool: createTools({
+      client: cockpit,
+      instance,
+      quiet,
+      env,
+      sessionTitle,
+      shellCommand: command => ({
+        command: userShell,
+        args: ["-c", command]
+      })
+    }),
+    "experimental.chat.system.transform": async (input, output) => {
+      output.system.push(GUIDANCE);
+      const running = await cockpit.call("shell.list", {
+        owner: {
+          project: directory
+        },
+        includeExited: false
+      }).catch(() => []);
+      if (running.length > 0) {
+        output.system.push(`Background shells currently running in this project:\n${running.slice(0, 15).map(s => {
+          const from = !s.owner.session ? ", started by the user" : s.owner.session === input.sessionID ? "" : ", another session";
+          return `- ${s.id} "${s.title}" (${describeStatus(s)}${from})`;
+        }).join("\n")}`);
+      }
+    },
+    event: async ({
+      event
+    }) => {
+      if (event.type !== "session.deleted") return;
+      const sessionID = event.properties.info.id;
+      const owned = await cockpit.call("shell.list", {
+        owner: {
+          session: sessionID
+        }
+      }).catch(() => []);
+      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/tools/find.js

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

package/dist/tools/format.js

@@ -0,0 +1,63 @@
+const MAX_LINE = 2000;
+
+/** Compact log lines for a model: numbered, long lines cut, consecutive repeats collapsed. */
+export function formatLines(lines) {
+  const out = [];
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    let j = i + 1;
+    while (j < lines.length && lines[j].text === line.text) j++;
+    const repeats = j - i;
+    const text = line.text.length > MAX_LINE ? `${line.text.slice(0, MAX_LINE)}… [${line.text.length - MAX_LINE} chars cut]` : line.text;
+    out.push(repeats > 1 ? `${line.n}| ${text}  (×${repeats}, lines ${line.n}-${line.n + repeats - 1})` : `${line.n}| ${text}`);
+    i = j;
+  }
+  return out.join("\n");
+}
+export function describeStatus(info) {
+  switch (info.status) {
+    case "running":
+      return `running (pid ${info.pid}, up ${duration(Date.now() - info.startedAt)})`;
+    case "exited":
+      return `exited with code ${info.exitCode ?? "?"} after ${duration((info.endedAt ?? Date.now()) - info.startedAt)}`;
+    case "killed":
+      return `killed${info.signal ? ` by ${info.signal}` : ""} after ${duration((info.endedAt ?? Date.now()) - info.startedAt)}`;
+    case "failed":
+      return `failed to start: ${info.error ?? "unknown error"}`;
+  }
+}
+export function header(info) {
+  const run = info.run > 1 ? ` run=${info.run}` : "";
+  return `<shell id="${info.id}" title="${info.title.replaceAll('"', "'")}" status="${info.status}"${run}>`;
+}
+export function formatRead(info, page, empty = "(no output yet)") {
+  const parts = [header(info), `status: ${describeStatus(info)}`];
+  if (page.truncated) parts.push(`(older lines were dropped from the buffer; oldest kept is ${page.firstLine})`);
+  parts.push(page.lines.length > 0 ? formatLines(page.lines) : empty);
+  if (page.hasMore) parts.push(`(more lines available: call shell_read with after=${page.nextCursor})`);
+  parts.push("</shell>", `cursor: ${page.nextCursor}`);
+  return parts.join("\n");
+}
+export function formatWait(result, timeoutSeconds) {
+  switch (result.reason) {
+    case "pattern":
+      return `condition met: pattern matched on line ${result.match?.n}: ${result.match?.text}`;
+    case "port":
+      return "condition met: port is accepting connections";
+    case "idle":
+      return "condition met: no output for the idle window (the program may be waiting for input)";
+    case "exit":
+      return `process ended: ${describeStatus(result.info)}`;
+    case "timeout":
+      return `timed out after ${timeoutSeconds}s without the condition being met; the shell is still ${result.info.status}`;
+  }
+}
+export function duration(ms) {
+  const s = Math.max(0, Math.round(ms / 1000));
+  if (s < 60) return `${s}s`;
+  const m = Math.floor(s / 60);
+  if (m < 60) return `${m}m${s % 60 ? `${s % 60}s` : ""}`;
+  const h = Math.floor(m / 60);
+  return `${h}h${m % 60 ? `${m % 60}m` : ""}`;
+}