@opencode-cockpit/protocol 0.1.3 → 0.1.5

package/src/daemon.ts

@@ -1,48 +0,0 @@
-import { z } from "zod"
-import { method } from "./contract.ts"
-
-export const ClientInfo = z.object({
-  name: z.string().min(1),
-  version: z.string().min(1),
-  pid: z.number().int().optional(),
-})
-
-export const Version = z.object({ major: z.number().int(), minor: z.number().int() })
-
-export const HelloResult = z.object({
-  daemonVersion: z.string(),
-  /** Content identity of the running daemon code (see daemonBuildId). */
-  build: z.string().optional(),
-  protocol: Version,
-  modules: z.array(z.string()),
-  pid: z.number().int(),
-  startedAt: z.number(),
-})
-
-export const StatusResult = z.object({
-  pid: z.number().int(),
-  uptimeMs: z.number(),
-  clients: z.number().int(),
-  modules: z.array(z.object({ name: z.string(), busy: z.boolean() })),
-})
-
-export const daemonContract = {
-  "daemon.hello": method(z.object({ client: ClientInfo, protocol: Version }), HelloResult),
-  "daemon.status": method(z.object({}).optional(), StatusResult),
-  "daemon.shutdown": method(
-    z.object({ force: z.boolean().optional() }).optional(),
-    z.object({ accepted: z.boolean() }),
-  ),
-  "events.subscribe": method(
-    z.object({ topics: z.array(z.string().min(1)).min(1) }),
-    z.object({ topics: z.array(z.string()) }),
-  ),
-  "events.unsubscribe": method(
-    z.object({ topics: z.array(z.string().min(1)).min(1) }),
-    z.object({ topics: z.array(z.string()) }),
-  ),
-}
-
-export type HelloResult = z.output<typeof HelloResult>
-export type StatusResult = z.output<typeof StatusResult>
-export type ClientInfo = z.output<typeof ClientInfo>

package/src/framing.ts

@@ -1,26 +0,0 @@
-/** NDJSON framing shared by daemon and client. */
-
-const encoder = new TextEncoder()
-
-export function encodeFrame(message: unknown): Uint8Array {
-  return encoder.encode(`${JSON.stringify(message)}\n`)
-}
-
-/** Accumulates chunks and yields complete lines. Bounded to protect against runaway peers. */
-export class LineDecoder {
-  private readonly decoder = new TextDecoder()
-  private pending = ""
-
-  constructor(private readonly maxLineBytes = 16 * 1024 * 1024) {}
-
-  push(chunk: Uint8Array): string[] {
-    this.pending += this.decoder.decode(chunk, { stream: true })
-    const parts = this.pending.split("\n")
-    this.pending = parts.pop() ?? ""
-    if (this.pending.length > this.maxLineBytes) {
-      this.pending = ""
-      throw new Error(`frame exceeds ${this.maxLineBytes} bytes`)
-    }
-    return parts.filter((line) => line.length > 0)
-  }
-}

package/src/index.ts

@@ -1,21 +0,0 @@
-import type { EventContract } from "./contract.ts"
-import { daemonContract } from "./daemon.ts"
-import { shellContract, shellEvents } from "./shell.ts"
-
-export * from "./build.ts"
-export * from "./contract.ts"
-export * from "./daemon.ts"
-export * from "./framing.ts"
-export * from "./paths.ts"
-export * from "./rpc.ts"
-export * as shell from "./shell.ts"
-
-/** Every method the daemon serves. Adding a module means spreading its contract here. */
-export const contract = { ...daemonContract, ...shellContract }
-export type Methods = typeof contract
-export type MethodName = keyof Methods
-
-/** Every event topic the daemon emits. */
-export const events = { ...shellEvents } satisfies EventContract
-export type Events = typeof events
-export type Topic = keyof Events

package/src/paths.ts

@@ -1,25 +0,0 @@
-import { homedir } from "node:os"
-import { join } from "node:path"
-
-export interface CockpitPaths {
-  home: string
-  socket: string
-  pidFile: string
-  lockFile: string
-  logFile: string
-}
-
-/**
- * Filesystem layout shared by daemon and clients. Pure: creates nothing.
- * Kept short because unix socket paths are limited to 104 bytes on macOS.
- */
-export function resolvePaths(env: Record<string, string | undefined> = process.env): CockpitPaths {
-  const home = env.COCKPIT_HOME ?? join(env.XDG_CACHE_HOME ?? join(homedir(), ".cache"), "opencode-cockpit")
-  return {
-    home,
-    socket: join(home, "cockpitd.sock"),
-    pidFile: join(home, "cockpitd.pid"),
-    lockFile: join(home, "spawn.lock"),
-    logFile: join(home, "cockpitd.log"),
-  }
-}

package/src/rpc.ts

@@ -1,96 +0,0 @@
-/** Wire envelope: JSON-RPC 2.0, one JSON object per line (ADR 0002). */
-
-/** Bump MAJOR on breaking changes to methods, events or framing. */
-export const PROTOCOL_VERSION = { major: 1, minor: 1 } as const
-
-export type RequestId = number | string
-
-export interface RpcRequest {
-  jsonrpc: "2.0"
-  id: RequestId
-  method: string
-  params?: unknown
-}
-
-export interface RpcNotification {
-  jsonrpc: "2.0"
-  method: string
-  params?: unknown
-}
-
-export interface RpcSuccess {
-  jsonrpc: "2.0"
-  id: RequestId
-  result: unknown
-}
-
-export interface RpcFailure {
-  jsonrpc: "2.0"
-  id: RequestId | null
-  error: RpcErrorShape
-}
-
-export type RpcMessage = RpcRequest | RpcNotification | RpcSuccess | RpcFailure
-
-export interface RpcErrorShape {
-  code: number
-  message: string
-  data?: unknown
-}
-
-export const ErrorCode = {
-  ParseError: -32700,
-  InvalidRequest: -32600,
-  MethodNotFound: -32601,
-  InvalidParams: -32602,
-  InternalError: -32603,
-  // Application range
-  NotFound: -32001,
-  InvalidState: -32002,
-  ProtocolMismatch: -32003,
-  SpawnFailed: -32004,
-  ShuttingDown: -32005,
-} as const
-
-export type ErrorCodeValue = (typeof ErrorCode)[keyof typeof ErrorCode]
-
-export class RpcError extends Error {
-  constructor(
-    readonly code: number,
-    message: string,
-    readonly data?: unknown,
-  ) {
-    super(message)
-    this.name = "RpcError"
-  }
-
-  toShape(): RpcErrorShape {
-    return this.data === undefined
-      ? { code: this.code, message: this.message }
-      : { code: this.code, message: this.message, data: this.data }
-  }
-
-  static from(shape: RpcErrorShape): RpcError {
-    return new RpcError(shape.code, shape.message, shape.data)
-  }
-}
-
-/** Method name for daemon → client notifications. */
-export const EVENT_METHOD = "event"
-
-export interface EventEnvelope<T extends string = string, D = unknown> {
-  topic: T
-  data: D
-}
-
-export function isRequest(msg: RpcMessage): msg is RpcRequest {
-  return "method" in msg && "id" in msg && msg.id !== undefined
-}
-
-export function isNotification(msg: RpcMessage): msg is RpcNotification {
-  return "method" in msg && !("id" in msg)
-}
-
-export function isResponse(msg: RpcMessage): msg is RpcSuccess | RpcFailure {
-  return !("method" in msg) && ("result" in msg || "error" in msg)
-}