@opencode-cockpit/daemon 0.1.4 → 0.1.5

package/dist/core/daemon.js

@@ -0,0 +1,193 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { daemonBuildId, ErrorCode, PROTOCOL_VERSION, RpcError } from "@opencode-cockpit/protocol";
+import pkg from "../../package.json" with { type: "json" };
+import { createLogger } from "./logger.js";
+import { Router } from "./router.js";
+import { RpcServer } from "./server.js";
+export const DAEMON_VERSION = pkg.version;
+
+/** Build id of this daemon's own code; computed once, matches what clients compute for the entry. */
+// The directory this module was loaded from: `src/` in a checkout, `dist/` once published.
+export const DAEMON_BUILD = daemonBuildId(Bun.fileURLToPath(new URL("..", import.meta.url)), DAEMON_VERSION);
+export class Daemon {
+  router = new Router();
+  startedAt = Date.now();
+  /** Resolves once the daemon has fully shut down. */
+  stopped = new Promise(resolve => {
+    this.resolveStopped = resolve;
+  });
+  constructor(options) {
+    this.options = options;
+    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() {
+    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") {
+    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;
+  }
+  busy() {
+    return this.options.modules.some(m => m.busy());
+  }
+  refreshIdle() {
+    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. */
+  async claimSocket(socket) {
+    if (!existsSync(socket)) return;
+    const alive = await new Promise(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
+    });
+  }
+  registerCore() {
+    this.router.add("daemon.hello", (raw, {
+      peer
+    }) => {
+      const params = raw;
+      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?.force === true;
+      if (this.busy() && !force) return {
+        accepted: false
+      };
+      setTimeout(() => void this.stop(force ? "forced shutdown" : "shutdown"), 10);
+      return {
+        accepted: true
+      };
+    });
+    const topics = on => (raw, {
+      peer
+    }) => {
+      const list = raw.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) {
+  try {
+    return Number.parseInt(readFileSync(file, "utf8"), 10);
+  } catch {
+    return undefined;
+  }
+}

package/dist/core/errors.js

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

package/dist/core/logger.js

@@ -0,0 +1,45 @@
+import { appendFileSync } from "node:fs";
+const order = {
+  debug: 10,
+  info: 20,
+  warn: 30,
+  error: 40
+};
+/** JSON-lines logger. Writes synchronously so the last lines survive a crash. */
+export function createLogger(file, level = "info", scope = "cockpitd") {
+  const write = (lvl, msg, fields) => {
+    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 = {
+  debug() {},
+  info() {},
+  warn() {},
+  error() {},
+  child: () => silentLogger
+};

package/dist/core/module.js

@@ -0,0 +1 @@
+export {};

package/dist/core/router.js

@@ -0,0 +1,33 @@
+import { contract, ErrorCode, RpcError } from "@opencode-cockpit/protocol";
+/** Validates params against the protocol contract and dispatches to module handlers. */
+export class Router {
+  handlers = new Map();
+  add(name, handler) {
+    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) {
+    for (const [short, handler] of Object.entries(module.methods)) {
+      this.add(`${module.name}.${short}`, handler.bind(module.methods));
+    }
+  }
+  has(name) {
+    return this.handlers.has(name);
+  }
+  async dispatch(name, params, call) {
+    const handler = this.handlers.get(name);
+    const spec = contract[name];
+    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/dist/core/server.js

@@ -0,0 +1,211 @@
+import { ErrorCode, EVENT_METHOD, encodeFrame, LineDecoder, RpcError } from "@opencode-cockpit/protocol";
+const MAX_QUEUED_BYTES = 32 * 1024 * 1024;
+class PeerImpl {
+  name = "unknown";
+  greeted = false;
+  topics = new Set();
+  closers = [];
+  queue = [];
+  queued = 0;
+  closed = false;
+  constructor(id, socket, log) {
+    this.id = id;
+    this.socket = socket;
+    this.log = log;
+  }
+  greet(name) {
+    this.name = name;
+    this.greeted = true;
+  }
+  onClose(fn) {
+    if (this.closed) fn();else this.closers.push(fn);
+  }
+  send(topic, data) {
+    this.write({
+      jsonrpc: "2.0",
+      method: EVENT_METHOD,
+      params: {
+        topic,
+        data
+      }
+    });
+  }
+  subscribed(topic) {
+    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) {
+    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() {
+    while (this.queue.length > 0) {
+      const head = this.queue[0];
+      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() {
+    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)
+        });
+      }
+    }
+  }
+  enqueue(frame) {
+    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 class RpcServer {
+  peers = new Set();
+  nextId = 1;
+  constructor(router, hooks, log) {
+    this.router = router;
+    this.hooks = hooks;
+    this.log = log;
+  }
+  get clientCount() {
+    return this.peers.size;
+  }
+  listen(path) {
+    const decoders = new WeakMap();
+    this.listener = Bun.listen({
+      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;
+          try {
+            lines = decoders.get(peer).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, data) {
+    for (const peer of this.peers) if (peer.subscribed(topic)) peer.send(topic, data);
+  }
+  stop() {
+    this.listener?.stop(true);
+    for (const peer of this.peers) peer.close();
+    this.peers.clear();
+  }
+  drop(peer) {
+    if (!this.peers.delete(peer)) return;
+    peer.close();
+    this.hooks.onDisconnect(this.peers.size);
+  }
+  async handleLine(peer, line) {
+    let message;
+    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;
+    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()
+      });
+    }
+  }
+  async invoke(peer, request) {
+    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
+    });
+  }
+}

package/dist/index.js

@@ -0,0 +1,3 @@
+export { DAEMON_BUILD, DAEMON_VERSION, Daemon } from "./core/daemon.js";
+export { createModules } from "./modules/index.js";
+export { ShellModule } from "./modules/shell/module.js";

package/dist/main.js

@@ -0,0 +1,40 @@
+#!/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.js";
+import { createModules } from "./modules/index.js";
+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 ?? "info",
+  logToFile: !foreground
+});
+for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"]) {
+  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/dist/modules/index.js

@@ -0,0 +1,5 @@
+import { ShellModule } from "./shell/module.js";
+/** Every capability the daemon hosts. Add new modules here. */
+export function createModules(options = {}) {
+  return [new ShellModule(options.shell)];
+}

package/dist/modules/shell/ids.js

@@ -0,0 +1,7 @@
+const ALPHABET = "abcdefghijklmnopqrstuvwxyz234567";
+export function newShellId() {
+  const bytes = crypto.getRandomValues(new Uint8Array(8));
+  let id = "sh_";
+  for (const byte of bytes) id += ALPHABET[byte % 32];
+  return id;
+}