@opencode-cockpit/shell 0.1.4 → 0.1.5

package/src/connect.ts

@@ -1,24 +0,0 @@
-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(): string {
-  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: string): CockpitClient {
-  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/src/server.ts

@@ -1,156 +0,0 @@
-import type { Hooks, Plugin, PluginInput, PluginModule } from "@opencode-ai/plugin"
-import { claimFeature, duplicateFeatureMessage } from "@opencode-cockpit/client"
-import type { ShellInfo } from "@opencode-cockpit/protocol/shell"
-import { createClient } from "./connect.ts"
-import { describeStatus, formatLines } from "./tools/format.ts"
-import { createTools } from "./tools/index.ts"
-
-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"
-
-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 function createShellServer({ source = SHELL_PACKAGE }: ShellServerOptions = {}): Plugin {
-  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 }: PluginInput): Promise<Hooks> {
-  const cockpit = createClient("opencode-cockpit/server")
-  const instance = crypto.randomUUID()
-  const quiet = new Set<string>()
-
-  const userShell =
-    process.env.SHELL && /(bash|zsh|fish|sh)$/.test(process.env.SHELL) ? process.env.SHELL : "/bin/bash"
-  const env = () => {
-    const out: Record<string, string> = {}
-    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<string, { title: string | undefined; at: number }>()
-  const sessionTitle = async (sessionID: string): Promise<string | undefined> => {
-    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 as { title?: string } | undefined)?.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: ShellInfo): Promise<void> {
-    const session = info.owner.session as string
-    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 } as never] },
-    })
-  }
-
-  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(() => [] as ShellInfo[])
-      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(() => [] as ShellInfo[])
-      for (const shell of owned) {
-        quiet.add(shell.id)
-        await cockpit.call("shell.remove", { id: shell.id }).catch(() => {})
-      }
-    },
-
-    dispose: async () => {
-      cockpit.close()
-    },
-  }
-}
-
-const plugin: PluginModule & { id: string } = { id: "opencode-cockpit.shell", server: createShellServer() }
-export default plugin

package/src/tools/find.ts

@@ -1,80 +0,0 @@
-import type { ShellInfo } from "@opencode-cockpit/protocol/shell"
-
-/** The command as written, without the `$SHELL -c` wrapper. */
-export function commandOf(s: ShellInfo): string {
-  return s.args.length === 2 && s.args[0] === "-c" ? (s.args[1] as string) : [s.command, ...s.args].join(" ")
-}
-
-export type StatusFilter = "running" | "failed" | "finished" | "any"
-export type SessionFilter = "this" | "others" | "any"
-
-export interface ShellFilter {
-  /** 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
-}
-
-export function isFailed(s: ShellInfo): boolean {
-  return s.status === "failed" || (s.status === "exited" && s.exitCode !== 0)
-}
-
-export function filterShells(list: readonly ShellInfo[], filter: ShellFilter): ShellInfo[] {
-  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
-    }
-  })
-}
-
-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 function matchByName(list: readonly ShellInfo[], name: string): NameMatch {
-  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] as ShellInfo, alsoMatched: [] }
-  const running = matches.filter((s) => s.status === "running")
-  if (running.length === 1) {
-    const shell = running[0] as ShellInfo
-    return { kind: "found", shell, alsoMatched: matches.filter((s) => s !== shell) }
-  }
-  return { kind: "ambiguous", candidates: matches }
-}

package/src/tools/format.ts

@@ -1,78 +0,0 @@
-import type { LogLine, ReadResult, ShellInfo, WaitResult } from "@opencode-cockpit/protocol/shell"
-
-const MAX_LINE = 2000
-
-/** Compact log lines for a model: numbered, long lines cut, consecutive repeats collapsed. */
-export function formatLines(lines: LogLine[]): string {
-  const out: string[] = []
-  let i = 0
-  while (i < lines.length) {
-    const line = lines[i] as LogLine
-    let j = i + 1
-    while (j < lines.length && (lines[j] as LogLine).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: ShellInfo): string {
-  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: ShellInfo): string {
-  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: ShellInfo, page: ReadResult, empty = "(no output yet)"): string {
-  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: WaitResult, timeoutSeconds: number): string {
-  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: number): string {
-  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` : ""}`
-}