@opencode-cockpit/protocol 0.1.4 → 0.2.0

package/types/shell/info.d.ts

@@ -0,0 +1,48 @@
+import { z } from "zod";
+export declare const ShellInfo: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    command: z.ZodString;
+    args: z.ZodArray<z.ZodString>;
+    cwd: z.ZodString;
+    owner: z.ZodObject<{
+        project: z.ZodString;
+        session: z.ZodOptional<z.ZodString>;
+        instance: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    status: z.ZodEnum<{
+        exited: "exited";
+        failed: "failed";
+        killed: "killed";
+        running: "running";
+    }>;
+    run: z.ZodNumber;
+    pid: z.ZodOptional<z.ZodNumber>;
+    exitCode: z.ZodOptional<z.ZodNumber>;
+    signal: z.ZodOptional<z.ZodString>;
+    error: z.ZodOptional<z.ZodString>;
+    summary: z.ZodOptional<z.ZodString>;
+    startedAt: z.ZodNumber;
+    endedAt: z.ZodOptional<z.ZodNumber>;
+    cols: z.ZodNumber;
+    rows: z.ZodNumber;
+    lines: z.ZodObject<{
+        first: z.ZodNumber;
+        last: z.ZodNumber;
+    }, z.core.$strip>;
+    bytes: z.ZodNumber;
+    watch: z.ZodOptional<z.ZodObject<{
+        preset: z.ZodOptional<z.ZodString>;
+        status: z.ZodEnum<{
+            fail: "fail";
+            ok: "ok";
+            pending: "pending";
+            unknown: "unknown";
+        }>;
+        summary: z.ZodOptional<z.ZodString>;
+        runs: z.ZodNumber;
+        since: z.ZodNumber;
+    }, z.core.$strip>>;
+    logFile: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ShellInfo = z.output<typeof ShellInfo>;

package/types/shell/params.d.ts

@@ -0,0 +1,215 @@
+import { z } from "zod";
+export declare const StartParams: z.ZodObject<{
+    command: z.ZodString;
+    args: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    cwd: z.ZodString;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    title: z.ZodOptional<z.ZodString>;
+    cols: z.ZodDefault<z.ZodNumber>;
+    rows: z.ZodDefault<z.ZodNumber>;
+    owner: z.ZodObject<{
+        project: z.ZodString;
+        session: z.ZodOptional<z.ZodString>;
+        instance: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+    idleTimeoutMs: z.ZodOptional<z.ZodNumber>;
+    logFile: z.ZodDefault<z.ZodBoolean>;
+    reuse: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const ClearParams: z.ZodDefault<z.ZodObject<{
+    owner: z.ZodOptional<z.ZodObject<{
+        project: z.ZodOptional<z.ZodString>;
+        session: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        instance: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    }, z.core.$strip>>;
+    finishedBeforeMs: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>>;
+export declare const ListParams: z.ZodDefault<z.ZodObject<{
+    owner: z.ZodOptional<z.ZodObject<{
+        project: z.ZodOptional<z.ZodString>;
+        session: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        instance: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    }, z.core.$strip>>;
+    includeExited: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>>;
+export declare const IdParams: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strip>;
+export declare const LogLine: z.ZodObject<{
+    n: z.ZodNumber;
+    text: z.ZodString;
+}, z.core.$strip>;
+export declare const ReadParams: z.ZodObject<{
+    id: z.ZodString;
+    after: z.ZodOptional<z.ZodNumber>;
+    tail: z.ZodDefault<z.ZodNumber>;
+    limit: z.ZodDefault<z.ZodNumber>;
+    grep: z.ZodOptional<z.ZodString>;
+    ignoreCase: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const ReadResult: z.ZodObject<{
+    lines: z.ZodArray<z.ZodObject<{
+        n: z.ZodNumber;
+        text: z.ZodString;
+    }, z.core.$strip>>;
+    firstLine: z.ZodNumber;
+    lastLine: z.ZodNumber;
+    nextCursor: z.ZodNumber;
+    truncated: z.ZodBoolean;
+    hasMore: z.ZodBoolean;
+    status: z.ZodEnum<{
+        exited: "exited";
+        failed: "failed";
+        killed: "killed";
+        running: "running";
+    }>;
+}, z.core.$strip>;
+/** A run of characters sharing one style, so a UI can repaint colour without parsing escapes. */
+export declare const ScreenRun: z.ZodObject<{
+    text: z.ZodString;
+    fg: z.ZodOptional<z.ZodString>;
+    bg: z.ZodOptional<z.ZodString>;
+    bold: z.ZodOptional<z.ZodBoolean>;
+    dim: z.ZodOptional<z.ZodBoolean>;
+    italic: z.ZodOptional<z.ZodBoolean>;
+    underline: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const ScreenResult: z.ZodObject<{
+    text: z.ZodString;
+    cols: z.ZodNumber;
+    rows: z.ZodNumber;
+    cursor: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>;
+    styled: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodObject<{
+        text: z.ZodString;
+        fg: z.ZodOptional<z.ZodString>;
+        bg: z.ZodOptional<z.ZodString>;
+        bold: z.ZodOptional<z.ZodBoolean>;
+        dim: z.ZodOptional<z.ZodBoolean>;
+        italic: z.ZodOptional<z.ZodBoolean>;
+        underline: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>>;
+}, z.core.$strip>;
+export declare const WriteParams: z.ZodObject<{
+    id: z.ZodString;
+    data: z.ZodString;
+}, z.core.$strip>;
+export declare const ResizeParams: z.ZodObject<{
+    id: z.ZodString;
+    cols: z.ZodNumber;
+    rows: z.ZodNumber;
+}, z.core.$strip>;
+export declare const WaitUntil: z.ZodObject<{
+    pattern: z.ZodOptional<z.ZodString>;
+    ignoreCase: z.ZodOptional<z.ZodBoolean>;
+    exit: z.ZodOptional<z.ZodBoolean>;
+    idleMs: z.ZodOptional<z.ZodNumber>;
+    port: z.ZodOptional<z.ZodNumber>;
+    host: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const WaitParams: z.ZodObject<{
+    id: z.ZodString;
+    until: z.ZodObject<{
+        pattern: z.ZodOptional<z.ZodString>;
+        ignoreCase: z.ZodOptional<z.ZodBoolean>;
+        exit: z.ZodOptional<z.ZodBoolean>;
+        idleMs: z.ZodOptional<z.ZodNumber>;
+        port: z.ZodOptional<z.ZodNumber>;
+        host: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    timeoutMs: z.ZodNumber;
+    after: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const WaitReason: z.ZodEnum<{
+    exit: "exit";
+    idle: "idle";
+    pattern: "pattern";
+    port: "port";
+    timeout: "timeout";
+}>;
+export declare const WaitResult: z.ZodObject<{
+    reason: z.ZodEnum<{
+        exit: "exit";
+        idle: "idle";
+        pattern: "pattern";
+        port: "port";
+        timeout: "timeout";
+    }>;
+    match: z.ZodOptional<z.ZodObject<{
+        n: z.ZodNumber;
+        text: z.ZodString;
+    }, z.core.$strip>>;
+    info: z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        command: z.ZodString;
+        args: z.ZodArray<z.ZodString>;
+        cwd: z.ZodString;
+        owner: z.ZodObject<{
+            project: z.ZodString;
+            session: z.ZodOptional<z.ZodString>;
+            instance: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        status: z.ZodEnum<{
+            exited: "exited";
+            failed: "failed";
+            killed: "killed";
+            running: "running";
+        }>;
+        run: z.ZodNumber;
+        pid: z.ZodOptional<z.ZodNumber>;
+        exitCode: z.ZodOptional<z.ZodNumber>;
+        signal: z.ZodOptional<z.ZodString>;
+        error: z.ZodOptional<z.ZodString>;
+        summary: z.ZodOptional<z.ZodString>;
+        startedAt: z.ZodNumber;
+        endedAt: z.ZodOptional<z.ZodNumber>;
+        cols: z.ZodNumber;
+        rows: z.ZodNumber;
+        lines: z.ZodObject<{
+            first: z.ZodNumber;
+            last: z.ZodNumber;
+        }, z.core.$strip>;
+        bytes: z.ZodNumber;
+        watch: z.ZodOptional<z.ZodObject<{
+            preset: z.ZodOptional<z.ZodString>;
+            status: z.ZodEnum<{
+                fail: "fail";
+                ok: "ok";
+                pending: "pending";
+                unknown: "unknown";
+            }>;
+            summary: z.ZodOptional<z.ZodString>;
+            runs: z.ZodNumber;
+            since: z.ZodNumber;
+        }, z.core.$strip>>;
+        logFile: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const StopParams: z.ZodObject<{
+    id: z.ZodString;
+    signal: z.ZodDefault<z.ZodEnum<{
+        SIGHUP: "SIGHUP";
+        SIGINT: "SIGINT";
+        SIGKILL: "SIGKILL";
+        SIGTERM: "SIGTERM";
+    }>>;
+    graceMs: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const AttachParams: z.ZodObject<{
+    id: z.ZodString;
+    fromOffset: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type StartParams = z.output<typeof StartParams>;
+export type ReadParams = z.output<typeof ReadParams>;
+export type ReadResult = z.output<typeof ReadResult>;
+export type ScreenResult = z.output<typeof ScreenResult>;
+export type ScreenRun = z.output<typeof ScreenRun>;
+export type WaitParams = z.output<typeof WaitParams>;
+export type WaitResult = z.output<typeof WaitResult>;
+export type WaitReason = z.output<typeof WaitReason>;
+export type StopParams = z.output<typeof StopParams>;
+export type LogLine = z.output<typeof LogLine>;

package/types/shell/watch.d.ts

@@ -0,0 +1,46 @@
+import { z } from "zod";
+/**
+ * A watch rule is three regexes over a shell's log, not a parser: `done` marks the end of a run
+ * (a compile, a test pass), `fail` and `ok` say how it went. Presets are just named rules, so a
+ * new tool is a table entry or a rule in the caller's config — never new code.
+ */
+export declare const WatchRule: z.ZodObject<{
+    done: z.ZodOptional<z.ZodString>;
+    fail: z.ZodOptional<z.ZodString>;
+    ok: z.ZodOptional<z.ZodString>;
+    ignoreCase: z.ZodOptional<z.ZodBoolean>;
+    idleSeconds: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const WatchStatus: z.ZodEnum<{
+    fail: "fail";
+    ok: "ok";
+    pending: "pending";
+    unknown: "unknown";
+}>;
+export declare const WatchState: z.ZodObject<{
+    preset: z.ZodOptional<z.ZodString>;
+    status: z.ZodEnum<{
+        fail: "fail";
+        ok: "ok";
+        pending: "pending";
+        unknown: "unknown";
+    }>;
+    summary: z.ZodOptional<z.ZodString>;
+    runs: z.ZodNumber;
+    since: z.ZodNumber;
+}, z.core.$strip>;
+export declare const WatchParams: z.ZodObject<{
+    id: z.ZodString;
+    preset: z.ZodOptional<z.ZodString>;
+    rule: z.ZodOptional<z.ZodObject<{
+        done: z.ZodOptional<z.ZodString>;
+        fail: z.ZodOptional<z.ZodString>;
+        ok: z.ZodOptional<z.ZodString>;
+        ignoreCase: z.ZodOptional<z.ZodBoolean>;
+        idleSeconds: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type WatchRule = z.output<typeof WatchRule>;
+export type WatchState = z.output<typeof WatchState>;
+export type WatchStatus = z.output<typeof WatchStatus>;
+export type WatchParams = z.output<typeof WatchParams>;

package/src/build.ts

@@ -1,32 +0,0 @@
-import { createHash } from "node:crypto"
-import { readdirSync, readFileSync, statSync } from "node:fs"
-import { dirname, join, relative } from "node:path"
-
-const SOURCE = /\.(ts|tsx|js|mjs|json)$/
-const SKIP = new Set(["node_modules", "test", "dist"])
-
-/**
- * Identity of the daemon code that `entry` would run: a hash of every source file in the entry's
- * package (its `src` directory, or the entry file itself when bundled). Daemon and client compute
- * it the same way, so a client can tell when a running daemon was started from different code.
- */
-export function daemonBuildId(entry: string, version: string): string {
-  const hash = createHash("sha256").update(version)
-  const root = dirname(entry)
-  const files = /[\\/]src$/.test(root) ? walk(root) : [entry]
-  for (const file of files.sort()) {
-    hash.update(relative(root, file)).update("\0").update(readFileSync(file)).update("\0")
-  }
-  return `${version}+${hash.digest("hex").slice(0, 12)}`
-}
-
-function walk(dir: string): string[] {
-  const out: string[] = []
-  for (const name of readdirSync(dir)) {
-    if (SKIP.has(name)) continue
-    const path = join(dir, name)
-    if (statSync(path).isDirectory()) out.push(...walk(path))
-    else if (SOURCE.test(name)) out.push(path)
-  }
-  return out
-}

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)
-}