@opencode-cockpit/daemon 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Codestz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,11 @@
+# @opencode-cockpit/daemon
+
+`cockpitd`, the long-lived process host. Owns PTY shells (each its own process group), normalizes output into clean logs, emulates the screen, implements wait conditions, reaps orphans after crashes and shuts down when idle. Capabilities are modules with a namespace, a method table and a lifecycle.
+
+Part of [opencode-cockpit](https://github.com/Codestz/opencode-cockpit). Install the plugin, not this package, unless you are building your own front end:
+
+```sh
+opencode plugin opencode-cockpit --global
+```
+
+Requires Bun ≥ 1.3.5 (OpenCode's embedded runtime qualifies). License: MIT.

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@opencode-cockpit/daemon",
+  "version": "0.1.0",
+  "description": "cockpitd: the process host behind opencode-cockpit (PTY shells, clean logs, wait conditions)",
+  "type": "module",
+  "license": "MIT",
+  "author": "Codestz",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Codestz/opencode-cockpit.git",
+    "directory": "packages/daemon"
+  },
+  "homepage": "https://github.com/Codestz/opencode-cockpit#readme",
+  "bugs": {
+    "url": "https://github.com/Codestz/opencode-cockpit/issues"
+  },
+  "keywords": [
+    "opencode",
+    "pty",
+    "daemon",
+    "terminal"
+  ],
+  "exports": {
+    ".": "./src/index.ts",
+    "./main": "./src/main.ts",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@opencode-cockpit/protocol": "0.0.1",
+    "@xterm/headless": "6.0.0"
+  },
+  "engines": {
+    "bun": ">=1.3.5"
+  }
+}

package/src/core/daemon.ts

@@ -0,0 +1,197 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs"
+import {
+  type CockpitPaths,
+  daemonBuildId,
+  ErrorCode,
+  PROTOCOL_VERSION,
+  RpcError,
+} from "@opencode-cockpit/protocol"
+import pkg from "../../package.json" with { type: "json" }
+import { createLogger, type Level, type Logger } from "./logger.ts"
+import type { Module } from "./module.ts"
+import { Router } from "./router.ts"
+import { RpcServer } from "./server.ts"
+
+export interface DaemonOptions {
+  paths: CockpitPaths
+  modules: Module[]
+  /** Shut down after this long with no clients and no busy module. 0 disables. */
+  idleTimeoutMs?: number
+  logLevel?: Level
+  /** Log to the log file (default) or stderr. */
+  logToFile?: boolean
+}
+
+export const DAEMON_VERSION: string = pkg.version
+
+/** Build id of this daemon's own code; computed once, matches what clients compute for the entry. */
+export const DAEMON_BUILD: string = daemonBuildId(
+  Bun.fileURLToPath(new URL("../main.ts", import.meta.url)),
+  DAEMON_VERSION,
+)
+
+export class Daemon {
+  readonly log: Logger
+  private readonly router = new Router()
+  private readonly server: RpcServer
+  private readonly startedAt = Date.now()
+  private idleTimer: ReturnType<typeof setTimeout> | undefined
+  private idleCheck: ReturnType<typeof setInterval> | undefined
+  private stopping: Promise<void> | undefined
+  private resolveStopped!: () => void
+  /** Resolves once the daemon has fully shut down. */
+  readonly stopped = new Promise<void>((resolve) => {
+    this.resolveStopped = resolve
+  })
+
+  constructor(private readonly options: DaemonOptions) {
+    this.log = createLogger(options.logToFile === false ? undefined : options.paths.logFile, options.logLevel)
+    this.server = new RpcServer(
+      this.router,
+      {
+        onConnect: () => this.refreshIdle(),
+        onDisconnect: () => this.refreshIdle(),
+      },
+      this.log.child("rpc"),
+    )
+    this.registerCore()
+    for (const module of options.modules) this.router.addModule(module)
+  }
+
+  async start(): Promise<void> {
+    const { paths } = this.options
+    mkdirSync(paths.home, { recursive: true, mode: 0o700 })
+    chmodSync(paths.home, 0o700)
+    await this.claimSocket(paths.socket)
+
+    for (const module of this.options.modules) {
+      await module.start({
+        log: this.log.child(module.name),
+        emit: (topic, data) => {
+          this.server.broadcast(topic, data)
+          // Module state changes (a shell exiting) can make the daemon idle.
+          this.refreshIdle()
+        },
+      })
+    }
+    this.server.listen(paths.socket)
+    chmodSync(paths.socket, 0o600)
+    writeFileSync(paths.pidFile, String(process.pid), { mode: 0o600 })
+    this.idleCheck = setInterval(() => this.refreshIdle(), 30_000)
+    this.refreshIdle()
+    this.log.info("daemon started", { pid: process.pid, build: DAEMON_BUILD, socket: paths.socket })
+  }
+
+  stop(reason = "requested"): Promise<void> {
+    this.stopping ??= (async () => {
+      this.log.info("daemon stopping", { reason })
+      clearTimeout(this.idleTimer)
+      clearInterval(this.idleCheck)
+      this.server.stop()
+      for (const module of [...this.options.modules].reverse()) {
+        try {
+          await module.stop()
+        } catch (err) {
+          this.log.error("module stop failed", { module: module.name, err: String(err) })
+        }
+      }
+      const { paths } = this.options
+      if (readPid(paths.pidFile) === process.pid) rmSync(paths.pidFile, { force: true })
+      rmSync(paths.socket, { force: true })
+      this.log.info("daemon stopped")
+      this.resolveStopped()
+    })()
+    return this.stopping
+  }
+
+  private busy(): boolean {
+    return this.options.modules.some((m) => m.busy())
+  }
+
+  private refreshIdle(): void {
+    const timeout = this.options.idleTimeoutMs ?? 0
+    if (timeout <= 0 || this.stopping) return
+    const idle = this.server.clientCount === 0 && !this.busy()
+    if (!idle) {
+      clearTimeout(this.idleTimer)
+      this.idleTimer = undefined
+    } else if (!this.idleTimer) {
+      this.idleTimer = setTimeout(() => {
+        if (this.server.clientCount === 0 && !this.busy()) void this.stop("idle")
+        else this.idleTimer = undefined
+      }, timeout)
+    }
+  }
+
+  /** Refuse to start if a live daemon owns the socket; otherwise clear a stale one. */
+  private async claimSocket(socket: string): Promise<void> {
+    if (!existsSync(socket)) return
+    const alive = await new Promise<boolean>((resolve) => {
+      Bun.connect({
+        unix: socket,
+        socket: {
+          open(s) {
+            s.end()
+            resolve(true)
+          },
+          data() {},
+          connectError: () => resolve(false),
+          error: () => resolve(false),
+        },
+      }).catch(() => resolve(false))
+    })
+    if (alive) throw new Error(`another daemon is listening on ${socket}`)
+    rmSync(socket, { force: true })
+  }
+
+  private registerCore(): void {
+    this.router.add("daemon.hello", (raw, { peer }) => {
+      const params = raw as { client: { name: string }; protocol: { major: number } }
+      if (params.protocol.major !== PROTOCOL_VERSION.major) {
+        throw new RpcError(ErrorCode.ProtocolMismatch, "protocol major version mismatch", {
+          daemon: PROTOCOL_VERSION,
+          client: params.protocol,
+          busy: this.busy(),
+        })
+      }
+      peer.greet(params.client.name)
+      return {
+        daemonVersion: DAEMON_VERSION,
+        build: DAEMON_BUILD,
+        protocol: PROTOCOL_VERSION,
+        modules: this.options.modules.map((m) => m.name),
+        pid: process.pid,
+        startedAt: this.startedAt,
+      }
+    })
+    this.router.add("daemon.status", () => ({
+      pid: process.pid,
+      uptimeMs: Date.now() - this.startedAt,
+      clients: this.server.clientCount,
+      modules: this.options.modules.map((m) => ({ name: m.name, busy: m.busy() })),
+    }))
+    this.router.add("daemon.shutdown", (raw) => {
+      const force = (raw as { force?: boolean } | undefined)?.force === true
+      if (this.busy() && !force) return { accepted: false }
+      setTimeout(() => void this.stop(force ? "forced shutdown" : "shutdown"), 10)
+      return { accepted: true }
+    })
+    const topics =
+      (on: boolean) =>
+      (raw: unknown, { peer }: { peer: { topics: Set<string> } }) => {
+        const list = (raw as { topics: string[] }).topics
+        for (const t of list) on ? peer.topics.add(t) : peer.topics.delete(t)
+        return { topics: [...peer.topics] }
+      }
+    this.router.add("events.subscribe", topics(true))
+    this.router.add("events.unsubscribe", topics(false))
+  }
+}
+
+function readPid(file: string): number | undefined {
+  try {
+    return Number.parseInt(readFileSync(file, "utf8"), 10)
+  } catch {
+    return undefined
+  }
+}

package/src/core/errors.ts

@@ -0,0 +1,6 @@
+import { ErrorCode, RpcError } from "@opencode-cockpit/protocol"
+
+export const notFound = (what: string) => new RpcError(ErrorCode.NotFound, `${what} not found`)
+export const invalidState = (message: string) => new RpcError(ErrorCode.InvalidState, message)
+export const invalidParams = (message: string, data?: unknown) =>
+  new RpcError(ErrorCode.InvalidParams, message, data)

package/src/core/logger.ts

@@ -0,0 +1,44 @@
+import { appendFileSync } from "node:fs"
+
+export type Level = "debug" | "info" | "warn" | "error"
+const order: Record<Level, number> = { debug: 10, info: 20, warn: 30, error: 40 }
+
+export interface Logger {
+  debug(msg: string, fields?: Record<string, unknown>): void
+  info(msg: string, fields?: Record<string, unknown>): void
+  warn(msg: string, fields?: Record<string, unknown>): void
+  error(msg: string, fields?: Record<string, unknown>): void
+  child(scope: string): Logger
+}
+
+/** JSON-lines logger. Writes synchronously so the last lines survive a crash. */
+export function createLogger(file: string | undefined, level: Level = "info", scope = "cockpitd"): Logger {
+  const write = (lvl: Level, msg: string, fields?: Record<string, unknown>) => {
+    if (order[lvl] < order[level]) return
+    const line = `${JSON.stringify({ t: new Date().toISOString(), lvl, scope, msg, ...fields })}\n`
+    if (file) {
+      try {
+        appendFileSync(file, line, { mode: 0o600 })
+      } catch {
+        process.stderr.write(line)
+      }
+    } else if (lvl !== "debug") {
+      process.stderr.write(line)
+    }
+  }
+  return {
+    debug: (m, f) => write("debug", m, f),
+    info: (m, f) => write("info", m, f),
+    warn: (m, f) => write("warn", m, f),
+    error: (m, f) => write("error", m, f),
+    child: (s) => createLogger(file, level, `${scope}:${s}`),
+  }
+}
+
+export const silentLogger: Logger = {
+  debug() {},
+  info() {},
+  warn() {},
+  error() {},
+  child: () => silentLogger,
+}

package/src/core/module.ts

@@ -0,0 +1,45 @@
+import type { MethodName, Methods, ParsedParamsOf, ResultOf } from "@opencode-cockpit/protocol"
+import type { Logger } from "./logger.ts"
+
+/** A connected client as seen by modules. */
+export interface Peer {
+  readonly id: number
+  readonly name: string
+  /** Send an event to this peer only, regardless of its subscriptions. */
+  send(topic: string, data: unknown): void
+  /** Run when the peer disconnects. */
+  onClose(fn: () => void): void
+  /** Topic patterns: exact (`shell.exited`), namespace (`shell.*`) or everything (`*`). */
+  readonly topics: Set<string>
+  greet(name: string): void
+}
+
+export interface CallContext {
+  peer: Peer
+}
+
+export interface ModuleContext {
+  log: Logger
+  /** Broadcast to every peer subscribed to `topic`. */
+  emit(topic: string, data: unknown): void
+}
+
+type Handler<M extends MethodName> = (
+  params: ParsedParamsOf<Methods, M>,
+  call: CallContext,
+) => Promise<ResultOf<Methods, M>> | ResultOf<Methods, M>
+
+/** Handlers for the methods under one namespace, typed from the protocol contract. */
+export type MethodTable<NS extends string> = {
+  [M in MethodName as M extends `${NS}.${infer Rest}` ? Rest : never]: Handler<M>
+}
+
+export interface Module<NS extends string = string> {
+  readonly name: NS
+  /** Typed per namespace; erased to a plain record when modules are handled generically. */
+  readonly methods: string extends NS ? object : MethodTable<NS>
+  start(ctx: ModuleContext): Promise<void>
+  stop(): Promise<void>
+  /** While true the daemon will not shut down for idleness. */
+  busy(): boolean
+}

package/src/core/router.ts

@@ -0,0 +1,40 @@
+import { contract, ErrorCode, RpcError } from "@opencode-cockpit/protocol"
+import type { CallContext, Module } from "./module.ts"
+
+type AnyHandler = (params: unknown, call: CallContext) => unknown
+
+/** Validates params against the protocol contract and dispatches to module handlers. */
+export class Router {
+  private readonly handlers = new Map<string, AnyHandler>()
+
+  add(name: string, handler: AnyHandler): void {
+    if (!(name in contract)) throw new Error(`method ${name} is not declared in the protocol contract`)
+    if (this.handlers.has(name)) throw new Error(`method ${name} registered twice`)
+    this.handlers.set(name, handler)
+  }
+
+  addModule(module: Module): void {
+    for (const [short, handler] of Object.entries(module.methods as Record<string, AnyHandler>)) {
+      this.add(`${module.name}.${short}`, handler.bind(module.methods))
+    }
+  }
+
+  has(name: string): boolean {
+    return this.handlers.has(name)
+  }
+
+  async dispatch(name: string, params: unknown, call: CallContext): Promise<unknown> {
+    const handler = this.handlers.get(name)
+    const spec = contract[name as keyof typeof contract]
+    if (!handler || !spec) throw new RpcError(ErrorCode.MethodNotFound, `unknown method ${name}`)
+    const parsed = spec.params.safeParse(params)
+    if (!parsed.success) {
+      throw new RpcError(
+        ErrorCode.InvalidParams,
+        `invalid params for ${name}: ${parsed.error.issues.map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`).join("; ")}`,
+        { issues: parsed.error.issues.map((i) => ({ path: i.path, message: i.message })) },
+      )
+    }
+    return handler(parsed.data, call)
+  }
+}

package/src/core/server.ts

@@ -0,0 +1,223 @@
+import {
+  ErrorCode,
+  EVENT_METHOD,
+  encodeFrame,
+  LineDecoder,
+  RpcError,
+  type RpcMessage,
+  type RpcRequest,
+} from "@opencode-cockpit/protocol"
+import type { Socket, UnixSocketListener } from "bun"
+import type { Logger } from "./logger.ts"
+import type { Peer } from "./module.ts"
+import type { Router } from "./router.ts"
+
+const MAX_QUEUED_BYTES = 32 * 1024 * 1024
+
+interface ConnState {
+  peer: PeerImpl
+}
+
+class PeerImpl implements Peer {
+  name = "unknown"
+  greeted = false
+  readonly topics = new Set<string>()
+  private readonly closers: (() => void)[] = []
+  private queue: Uint8Array[] = []
+  private queued = 0
+  closed = false
+
+  constructor(
+    readonly id: number,
+    private readonly socket: Socket<ConnState>,
+    private readonly log: Logger,
+  ) {}
+
+  greet(name: string): void {
+    this.name = name
+    this.greeted = true
+  }
+
+  onClose(fn: () => void): void {
+    if (this.closed) fn()
+    else this.closers.push(fn)
+  }
+
+  send(topic: string, data: unknown): void {
+    this.write({ jsonrpc: "2.0", method: EVENT_METHOD, params: { topic, data } })
+  }
+
+  subscribed(topic: string): boolean {
+    if (this.topics.has(topic) || this.topics.has("*")) return true
+    const dot = topic.indexOf(".")
+    return dot > 0 && this.topics.has(`${topic.slice(0, dot)}.*`)
+  }
+
+  write(message: unknown): void {
+    if (this.closed) return
+    const frame = encodeFrame(message)
+    if (this.queue.length > 0) {
+      this.enqueue(frame)
+      return
+    }
+    const written = this.socket.write(frame)
+    if (written < frame.byteLength) this.enqueue(frame.subarray(Math.max(0, written)))
+  }
+
+  drain(): void {
+    while (this.queue.length > 0) {
+      const head = this.queue[0] as Uint8Array
+      const written = this.socket.write(head)
+      if (written < head.byteLength) {
+        this.queue[0] = head.subarray(Math.max(0, written))
+        this.queued -= Math.max(0, written)
+        return
+      }
+      this.queue.shift()
+      this.queued -= head.byteLength
+    }
+  }
+
+  close(): void {
+    if (this.closed) return
+    this.closed = true
+    this.queue = []
+    for (const fn of this.closers.splice(0)) {
+      try {
+        fn()
+      } catch (err) {
+        this.log.warn("peer close hook failed", { err: String(err) })
+      }
+    }
+  }
+
+  private enqueue(frame: Uint8Array): void {
+    this.queue.push(frame)
+    this.queued += frame.byteLength
+    if (this.queued > MAX_QUEUED_BYTES) {
+      this.log.warn("peer too slow, disconnecting", { peer: this.id, queued: this.queued })
+      this.socket.end()
+    }
+  }
+}
+
+export interface RpcServerHooks {
+  onConnect(count: number): void
+  onDisconnect(count: number): void
+}
+
+export class RpcServer {
+  private listener: UnixSocketListener<ConnState> | undefined
+  private readonly peers = new Set<PeerImpl>()
+  private nextId = 1
+
+  constructor(
+    private readonly router: Router,
+    private readonly hooks: RpcServerHooks,
+    private readonly log: Logger,
+  ) {}
+
+  get clientCount(): number {
+    return this.peers.size
+  }
+
+  listen(path: string): void {
+    const decoders = new WeakMap<PeerImpl, LineDecoder>()
+    this.listener = Bun.listen<ConnState>({
+      unix: path,
+      socket: {
+        open: (socket) => {
+          const peer = new PeerImpl(this.nextId++, socket, this.log)
+          socket.data = { peer }
+          decoders.set(peer, new LineDecoder())
+          this.peers.add(peer)
+          this.hooks.onConnect(this.peers.size)
+        },
+        data: (socket, chunk) => {
+          const peer = socket.data.peer
+          let lines: string[]
+          try {
+            lines = (decoders.get(peer) as LineDecoder).push(chunk)
+          } catch (err) {
+            peer.write({
+              jsonrpc: "2.0",
+              id: null,
+              error: { code: ErrorCode.ParseError, message: String(err) },
+            })
+            socket.end()
+            return
+          }
+          for (const line of lines) void this.handleLine(peer, line)
+        },
+        drain: (socket) => socket.data.peer.drain(),
+        close: (socket) => this.drop(socket.data.peer),
+        error: (socket, err) => {
+          this.log.warn("socket error", { err: String(err) })
+          this.drop(socket.data.peer)
+        },
+      },
+    })
+  }
+
+  broadcast(topic: string, data: unknown): void {
+    for (const peer of this.peers) if (peer.subscribed(topic)) peer.send(topic, data)
+  }
+
+  stop(): void {
+    this.listener?.stop(true)
+    for (const peer of this.peers) peer.close()
+    this.peers.clear()
+  }
+
+  private drop(peer: PeerImpl): void {
+    if (!this.peers.delete(peer)) return
+    peer.close()
+    this.hooks.onDisconnect(this.peers.size)
+  }
+
+  private async handleLine(peer: PeerImpl, line: string): Promise<void> {
+    let message: RpcMessage
+    try {
+      message = JSON.parse(line)
+    } catch {
+      peer.write({ jsonrpc: "2.0", id: null, error: { code: ErrorCode.ParseError, message: "invalid JSON" } })
+      return
+    }
+    if (
+      typeof message !== "object" ||
+      message === null ||
+      !("method" in message) ||
+      typeof message.method !== "string"
+    ) {
+      peer.write({
+        jsonrpc: "2.0",
+        id: null,
+        error: { code: ErrorCode.InvalidRequest, message: "expected a request" },
+      })
+      return
+    }
+    const hasId = "id" in message && (typeof message.id === "number" || typeof message.id === "string")
+    const request = message as RpcRequest
+    try {
+      const result = await this.invoke(peer, request)
+      if (hasId) peer.write({ jsonrpc: "2.0", id: request.id, result: result ?? {} })
+    } catch (err) {
+      const rpc =
+        err instanceof RpcError
+          ? err
+          : new RpcError(ErrorCode.InternalError, err instanceof Error ? err.message : String(err))
+      if (!(err instanceof RpcError))
+        this.log.error("handler crashed", { method: request.method, err: String(err) })
+      if (hasId) peer.write({ jsonrpc: "2.0", id: request.id, error: rpc.toShape() })
+    }
+  }
+
+  private async invoke(peer: PeerImpl, request: RpcRequest): Promise<unknown> {
+    if (!peer.greeted && request.method !== "daemon.hello") {
+      throw new RpcError(ErrorCode.InvalidRequest, "call daemon.hello first")
+    }
+    return this.router.dispatch(request.method, request.params, { peer })
+  }
+}
+
+export type { PeerImpl }

package/src/index.ts

@@ -0,0 +1,5 @@
+export { DAEMON_BUILD, DAEMON_VERSION, Daemon, type DaemonOptions } from "./core/daemon.ts"
+export type { CallContext, MethodTable, Module, ModuleContext, Peer } from "./core/module.ts"
+export { createModules, type ModuleOptions } from "./modules/index.ts"
+export { ShellModule, type ShellModuleOptions } from "./modules/shell/module.ts"
+export type { PtyBackend, PtyProcess, PtySpawnOptions } from "./modules/shell/pty.ts"

package/src/main.ts

@@ -0,0 +1,36 @@
+#!/usr/bin/env bun
+/** cockpitd entry point. Started detached by clients (ADR 0001); safe to run by hand for debugging. */
+import { join } from "node:path"
+import { resolvePaths } from "@opencode-cockpit/protocol"
+import { Daemon } from "./core/daemon.ts"
+import type { Level } from "./core/logger.ts"
+import { createModules } from "./modules/index.ts"
+
+const env = process.env
+const foreground = process.argv.includes("--foreground")
+
+const paths = resolvePaths(env)
+const daemon = new Daemon({
+  paths,
+  modules: createModules({ shell: { registryFile: join(paths.home, "shells.json") } }),
+  idleTimeoutMs: Number(env.COCKPIT_IDLE_TIMEOUT_MS ?? 10 * 60_000),
+  logLevel: (env.COCKPIT_LOG_LEVEL as Level | undefined) ?? "info",
+  logToFile: !foreground,
+})
+
+for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"] as const) {
+  process.on(signal, () => void daemon.stop(signal))
+}
+process.on("uncaughtException", (err) =>
+  daemon.log.error("uncaught exception", { err: String(err), stack: err.stack }),
+)
+process.on("unhandledRejection", (err) => daemon.log.error("unhandled rejection", { err: String(err) }))
+
+try {
+  await daemon.start()
+} catch (err) {
+  daemon.log.error("failed to start", { err: String(err) })
+  process.exit(1)
+}
+await daemon.stopped
+process.exit(0)

package/src/modules/index.ts

@@ -0,0 +1,11 @@
+import type { Module } from "../core/module.ts"
+import { ShellModule, type ShellModuleOptions } from "./shell/module.ts"
+
+export interface ModuleOptions {
+  shell?: ShellModuleOptions
+}
+
+/** Every capability the daemon hosts. Add new modules here. */
+export function createModules(options: ModuleOptions = {}): Module[] {
+  return [new ShellModule(options.shell)]
+}