@scrylog/cli 0.1.0

package/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "@scrylog/cli",
+  "version": "0.1.0",
+  "description": "Terminal dashboard for monitoring tmux sessions running AI coding agents",
+  "license": "MIT",
+  "type": "module",
+  "author": "Joel D. Martinez",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/scrylog/scrylog.git",
+    "directory": "apps/cli"
+  },
+  "homepage": "https://github.com/scrylog/scrylog#readme",
+  "bugs": {
+    "url": "https://github.com/scrylog/scrylog/issues"
+  },
+  "keywords": [
+    "tmux",
+    "tui",
+    "terminal",
+    "bun",
+    "ssh",
+    "cli",
+    "opencode",
+    "codex",
+    "mcp",
+    "claude",
+    "dashboard"
+  ],
+  "engines": {
+    "bun": ">=1.3.0"
+  },
+  "bin": {
+    "scrylog": "src/tui/index.ts",
+    "scrylogd": "src/daemon/index.ts",
+    "scrylog-mcp": "src/mcp/index.ts",
+    "scrylog-claude-hook": "src/hooks/claude.ts",
+    "scrylog-codex-hook": "src/hooks/codex.ts",
+    "oc": "src/oc/index.ts"
+  },
+  "files": [
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "clean": "rm -rf .turbo && rm -rf dist",
+    "clean:node-modules": "rm -rf node_modules",
+    "dev": "bun run src/tui/index.ts",
+    "dev:daemon": "bun run src/daemon/index.ts",
+    "start": "bun run src/tui/index.ts",
+    "check-types": "tsc --noEmit",
+    "test": "bun test",
+    "pack:dry-run": "npm pack --dry-run"
+  },
+  "dependencies": {
+    "@hono/zod-openapi": "^1.3.0",
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "@opencode-ai/sdk": "1.4.10",
+    "@scalar/hono-api-reference": "^0.10.11",
+    "@scalar/openapi-to-markdown": "^0.5.9",
+    "hono": "^4.12.15",
+    "neo-blessed": "^0.2.0",
+    "zod": "catalog:"
+  },
+  "devDependencies": {
+    "@types/blessed": "^0.1.27",
+    "@types/bun": "catalog:",
+    "@types/node": "catalog:",
+    "typescript": "catalog:"
+  }
+}

package/src/api/docs/sessions.keys.ts

@@ -0,0 +1,6 @@
+export enum SessionRouteKey {
+  LIST_SESSIONS = "LIST_SESSIONS",
+  SESSION_CHILDREN = "SESSION_CHILDREN",
+  SESSION_MESSAGES = "SESSION_MESSAGES",
+  SESSION_DETAIL = "SESSION_DETAIL",
+}

package/src/api/docs/sessions.ts

@@ -0,0 +1,81 @@
+import type { RouteConfig } from "@hono/zod-openapi";
+import { ApiErrorSchema, SessionIdParamSchema } from "../schemas/common";
+import {
+  SessionsResponseSchema,
+  SessionDetailResponseSchema,
+  SessionChildrenResponseSchema,
+  SessionMessagesResponseSchema,
+} from "../schemas/sessions";
+import { SessionRouteKey } from "./sessions.keys";
+
+export const SessionRoutes = {
+  [SessionRouteKey.LIST_SESSIONS]: {
+    method: "get",
+    path: "/sessions",
+    tags: ["Sessions"],
+    summary: "List sessions",
+    description: "Returns the full session tree with counts.",
+    security: [{ BearerAuth: [] }],
+    responses: {
+      200: {
+        content: { "application/json": { schema: SessionsResponseSchema } },
+        description: "Session tree",
+      },
+    },
+  },
+  [SessionRouteKey.SESSION_CHILDREN]: {
+    method: "get",
+    path: "/sessions/{id}/children",
+    tags: ["Sessions"],
+    summary: "List session children",
+    security: [{ BearerAuth: [] }],
+    request: { params: SessionIdParamSchema },
+    responses: {
+      200: {
+        content: { "application/json": { schema: SessionChildrenResponseSchema } },
+        description: "Child sessions",
+      },
+      404: {
+        content: { "application/json": { schema: ApiErrorSchema } },
+        description: "Session not found",
+      },
+    },
+  },
+  [SessionRouteKey.SESSION_MESSAGES]: {
+    method: "get",
+    path: "/sessions/{id}/messages",
+    tags: ["Sessions"],
+    summary: "List session messages",
+    description: "Message history for a session (placeholder — always returns empty array).",
+    security: [{ BearerAuth: [] }],
+    request: { params: SessionIdParamSchema },
+    responses: {
+      200: {
+        content: { "application/json": { schema: SessionMessagesResponseSchema } },
+        description: "Message list",
+      },
+      404: {
+        content: { "application/json": { schema: ApiErrorSchema } },
+        description: "Session not found",
+      },
+    },
+  },
+  [SessionRouteKey.SESSION_DETAIL]: {
+    method: "get",
+    path: "/sessions/{id}",
+    tags: ["Sessions"],
+    summary: "Get session",
+    security: [{ BearerAuth: [] }],
+    request: { params: SessionIdParamSchema },
+    responses: {
+      200: {
+        content: { "application/json": { schema: SessionDetailResponseSchema } },
+        description: "Session detail",
+      },
+      404: {
+        content: { "application/json": { schema: ApiErrorSchema } },
+        description: "Session not found",
+      },
+    },
+  },
+} satisfies Record<SessionRouteKey, RouteConfig>;

package/src/api/docs/system.keys.ts

@@ -0,0 +1,5 @@
+export enum SystemRouteKey {
+  HEALTH = "HEALTH",
+  STATUS = "STATUS",
+  CONFIG = "CONFIG",
+}

package/src/api/docs/system.ts

@@ -0,0 +1,66 @@
+import { z } from "@hono/zod-openapi";
+import type { RouteConfig } from "@hono/zod-openapi";
+import { SystemRouteKey } from "./system.keys";
+
+export const SystemRoutes = {
+  [SystemRouteKey.HEALTH]: {
+    method: "get",
+    path: "/health",
+    tags: ["System"],
+    summary: "Health check",
+    responses: {
+      200: {
+        content: {
+          "application/json": {
+            schema: z.object({
+              ok: z.literal(true),
+              startedAt: z.number(),
+              refreshedAt: z.number(),
+              collectors: z.record(z.string(), z.unknown()),
+            }),
+          },
+        },
+        description: "Daemon is running",
+      },
+    },
+  },
+  [SystemRouteKey.STATUS]: {
+    method: "get",
+    path: "/status",
+    tags: ["System"],
+    summary: "Session counts and collector status",
+    security: [{ BearerAuth: [] }],
+    responses: {
+      200: {
+        content: {
+          "application/json": {
+            schema: z.object({
+              counts: z.record(z.string(), z.unknown()),
+              collectorStatus: z.record(z.string(), z.unknown()),
+              generatedAt: z.number(),
+            }),
+          },
+        },
+        description: "Current status",
+      },
+    },
+  },
+  [SystemRouteKey.CONFIG]: {
+    method: "get",
+    path: "/config",
+    tags: ["System"],
+    summary: "Current daemon configuration",
+    description: "Bearer token is redacted in the response.",
+    security: [{ BearerAuth: [] }],
+    responses: {
+      200: {
+        content: {
+          "application/json": {
+            schema: z.object({ config: z.record(z.string(), z.unknown()) }),
+          },
+        },
+        description: "Configuration",
+      },
+    },
+  },
+} satisfies Record<SystemRouteKey, RouteConfig>;

package/src/api/docs/usage.keys.ts

@@ -0,0 +1,3 @@
+export enum UsageRouteKey {
+  GET_USAGE = "GET_USAGE",
+}

package/src/api/docs/usage.ts

@@ -0,0 +1,24 @@
+import { z } from "@hono/zod-openapi";
+import type { RouteConfig } from "@hono/zod-openapi";
+import { UsageRouteKey } from "./usage.keys";
+import { UsageResponseSchema } from "../schemas/usage";
+
+export const UsageRoutes = {
+  [UsageRouteKey.GET_USAGE]: {
+    method: "get",
+    path: "/usage",
+    tags: ["Usage"],
+    summary: "Get subscription usage limits",
+    security: [{ BearerAuth: [] }],
+    responses: {
+      200: {
+        content: {
+          "application/json": {
+            schema: UsageResponseSchema,
+          },
+        },
+        description: "Current usage data for all configured providers",
+      },
+    },
+  },
+} satisfies Record<UsageRouteKey, RouteConfig>;

package/src/api/docs/webhooks.keys.ts

@@ -0,0 +1,5 @@
+export enum WebhookRouteKey {
+  WEBHOOK_OPENCODE = "WEBHOOK_OPENCODE",
+  WEBHOOK_CLAUDE = "WEBHOOK_CLAUDE",
+  WEBHOOK_CODEX = "WEBHOOK_CODEX",
+}

package/src/api/docs/webhooks.ts

@@ -0,0 +1,78 @@
+import type { RouteConfig } from "@hono/zod-openapi";
+import { ApiErrorSchema, WebhookOkSchema } from "../schemas/common";
+import { OpencodeWebhookBodySchema } from "../schemas/webhooks/opencode";
+import { ClaudeWebhookBodySchema } from "../schemas/webhooks/claude";
+import { CodexWebhookBodySchema } from "../schemas/webhooks/codex";
+import { WebhookRouteKey } from "./webhooks.keys";
+
+export const WebhookRoutes = {
+  [WebhookRouteKey.WEBHOOK_OPENCODE]: {
+    method: "post",
+    path: "/opencode",
+    tags: ["Webhooks"],
+    summary: "OpenCode session hook",
+    description: "Receives lifecycle events from OpenCode webhooks.",
+    request: {
+      body: {
+        required: true,
+        content: { "application/json": { schema: OpencodeWebhookBodySchema } },
+      },
+    },
+    responses: {
+      200: {
+        content: { "application/json": { schema: WebhookOkSchema } },
+        description: "Event accepted",
+      },
+      400: {
+        content: { "application/json": { schema: ApiErrorSchema } },
+        description: "Missing required field",
+      },
+    },
+  },
+  [WebhookRouteKey.WEBHOOK_CLAUDE]: {
+    method: "post",
+    path: "/claude",
+    tags: ["Webhooks"],
+    summary: "Claude session hook",
+    description: "Receives lifecycle events from the Claude CLI hooks system.",
+    request: {
+      body: {
+        required: true,
+        content: { "application/json": { schema: ClaudeWebhookBodySchema } },
+      },
+    },
+    responses: {
+      200: {
+        content: { "application/json": { schema: WebhookOkSchema } },
+        description: "Event accepted",
+      },
+      400: {
+        content: { "application/json": { schema: ApiErrorSchema } },
+        description: "Missing required field",
+      },
+    },
+  },
+  [WebhookRouteKey.WEBHOOK_CODEX]: {
+    method: "post",
+    path: "/codex",
+    tags: ["Webhooks"],
+    summary: "Codex session hook",
+    description: "Receives lifecycle events from the Codex CLI hooks system.",
+    request: {
+      body: {
+        required: true,
+        content: { "application/json": { schema: CodexWebhookBodySchema } },
+      },
+    },
+    responses: {
+      200: {
+        content: { "application/json": { schema: WebhookOkSchema } },
+        description: "Event accepted",
+      },
+      400: {
+        content: { "application/json": { schema: ApiErrorSchema } },
+        description: "Missing required field",
+      },
+    },
+  },
+} satisfies Record<WebhookRouteKey, RouteConfig>;

package/src/api/index.ts

@@ -0,0 +1,18 @@
+import type { ScrylogConfig } from "../shared/config";
+import type { DaemonStore } from "../daemon/store";
+import type { GitCollector } from "../daemon/collectors/git";
+import type { Logger } from "../shared/logger";
+import { createApiApp } from "./routes";
+
+/**
+ * Create the fetch handler for the daemon HTTP API.
+ * Used by both the Unix socket and TCP listeners (same handler, two servers).
+ */
+export function createApiHandler(
+  store: DaemonStore,
+  config: ScrylogConfig,
+  logger: Logger,
+  gitCollector?: GitCollector,
+): (request: Request) => Response | Promise<Response> {
+  return createApiApp(store, config, logger, gitCollector).fetch;
+}

package/src/api/lib/auth.ts

@@ -0,0 +1,43 @@
+import { timingSafeEqual } from "node:crypto";
+import type { MiddlewareHandler } from "hono";
+import { UnauthorizedError } from "./errors";
+
+function secureCompare(a: string, b: string): boolean {
+  const bufA = Buffer.from(a, "utf-8");
+  const bufB = Buffer.from(b, "utf-8");
+  if (bufA.length !== bufB.length) return false;
+  return timingSafeEqual(bufA, bufB);
+}
+
+export function createBearerAuthMiddleware(bearerToken: string | undefined): MiddlewareHandler {
+  const PUBLIC_PATHS = [
+    "/api/health",
+    "/api/docs",
+    "/api/openapi.json",
+    "/api/llms.txt",
+  ];
+
+  return async (c, next) => {
+    if (!bearerToken) {
+      return next();
+    }
+
+    const path = c.req.path;
+
+    if (PUBLIC_PATHS.includes(path)) {
+      return next();
+    }
+
+    if (path.startsWith("/api/webhook/")) {
+      return next();
+    }
+
+    const auth = c.req.header("Authorization");
+    const expected = `Bearer ${bearerToken}`;
+    if (!auth || !secureCompare(auth, expected)) {
+      throw new UnauthorizedError();
+    }
+
+    return next();
+  };
+}

package/src/api/lib/errors.ts

@@ -0,0 +1,28 @@
+export class ApiError extends Error {
+  constructor(
+    public readonly status: number,
+    public readonly code: string,
+    message: string,
+  ) {
+    super(message);
+    this.name = "ApiError";
+  }
+}
+
+export class NotFoundError extends ApiError {
+  constructor(resource: string, id: string) {
+    super(404, "NOT_FOUND", `${resource} '${id}' not found`);
+  }
+}
+
+export class UnauthorizedError extends ApiError {
+  constructor() {
+    super(401, "UNAUTHORIZED", "Unauthorized");
+  }
+}
+
+export class ValidationError extends ApiError {
+  constructor(message: string) {
+    super(400, "VALIDATION_ERROR", message);
+  }
+}

package/src/api/lib/route.ts

@@ -0,0 +1,18 @@
+import { createRoute } from "@hono/zod-openapi";
+import { SystemRoutes } from "../docs/system";
+import { SessionRoutes } from "../docs/sessions";
+import { WebhookRoutes } from "../docs/webhooks";
+import { UsageRoutes } from "../docs/usage";
+
+const _registry = {
+  ...SystemRoutes,
+  ...SessionRoutes,
+  ...WebhookRoutes,
+  ...UsageRoutes,
+};
+
+export type RouteKey = keyof typeof _registry;
+
+export function defineRoute<K extends RouteKey>(key: K) {
+  return createRoute(_registry[key] as (typeof _registry)[K]);
+}

package/src/api/models/claude.ts

@@ -0,0 +1,4 @@
+import type { z } from "@hono/zod-openapi";
+import type { ClaudeWebhookBodySchema } from "../schemas/webhooks/claude";
+
+export type ClaudeWebhookPayload = z.infer<typeof ClaudeWebhookBodySchema>;

package/src/api/models/codex.ts

@@ -0,0 +1,4 @@
+import type { z } from "@hono/zod-openapi";
+import type { CodexWebhookBodySchema } from "../schemas/webhooks/codex";
+
+export type CodexWebhookPayload = z.infer<typeof CodexWebhookBodySchema>;

package/src/api/models/opencode.ts

@@ -0,0 +1,11 @@
+import type { z } from "@hono/zod-openapi";
+import type { OpencodeWebhookBodySchema } from "../schemas/webhooks/opencode";
+import type { SessionState } from "../../shared/types";
+
+export type OpencodeWebhookPayload = z.infer<typeof OpencodeWebhookBodySchema>;
+
+export interface HookStateResult {
+  state: SessionState;
+  hasAttention: boolean;
+  pendingAttentionCount?: number;
+}

package/src/api/routes/sessions.ts

@@ -0,0 +1,47 @@
+import { OpenAPIHono } from "@hono/zod-openapi";
+import type { ScrylogConfig } from "../../shared/config";
+import type { DaemonStore } from "../../daemon/store";
+import { buildSessionView } from "../../shared/session-view";
+import { NotFoundError } from "../lib/errors";
+import { SessionRouteKey } from "../docs/sessions.keys";
+import { defineRoute } from "../lib/route";
+
+export function createSessionsRouter(store: DaemonStore, config: ScrylogConfig): OpenAPIHono {
+  const router = new OpenAPIHono();
+
+  router.openapi(defineRoute(SessionRouteKey.LIST_SESSIONS), (c) => {
+    const view = buildSessionView(store.getSessions(), config);
+    return c.json({ sessions: view.sessions, counts: view.counts, generatedAt: store.getState().refreshedAt }, 200);
+  });
+
+  // Must be registered before /:id to avoid the wildcard swallowing the path
+  router.openapi(defineRoute(SessionRouteKey.SESSION_CHILDREN), (c) => {
+    const { id } = c.req.valid("param");
+    const parent = store.getSession(id);
+    if (!parent) {
+      throw new NotFoundError("Session", id);
+    }
+    const children = buildSessionView(store.getSessions(), config).sessions.find((s) => s.id === id)?.children ?? [];
+    return c.json({ sessionId: id, children }, 200);
+  });
+
+  router.openapi(defineRoute(SessionRouteKey.SESSION_MESSAGES), (c) => {
+    const { id } = c.req.valid("param");
+    const session = store.getSession(id);
+    if (!session) {
+      throw new NotFoundError("Session", id);
+    }
+    return c.json({ sessionId: id, messages: [] }, 200);
+  });
+
+  router.openapi(defineRoute(SessionRouteKey.SESSION_DETAIL), (c) => {
+    const { id } = c.req.valid("param");
+    const session = store.getSession(id);
+    if (!session) {
+      throw new NotFoundError("Session", id);
+    }
+    return c.json({ session: session as unknown as Record<string, unknown> }, 200);
+  });
+
+  return router;
+}

package/src/api/routes/system.ts

@@ -0,0 +1,103 @@
+import { OpenAPIHono } from "@hono/zod-openapi";
+import { streamSSE } from "hono/streaming";
+import type { ScrylogConfig } from "../../shared/config";
+import type { DaemonStore } from "../../daemon/store";
+import type { Logger } from "../../shared/logger";
+import { buildSessionView } from "../../shared/session-view";
+import { SystemRouteKey } from "../docs/system.keys";
+import { defineRoute } from "../lib/route";
+
+export function createSystemRouter(store: DaemonStore, config: ScrylogConfig, logger: Logger): OpenAPIHono {
+  const router = new OpenAPIHono();
+
+  router.openapi(defineRoute(SystemRouteKey.HEALTH), (c) => {
+    const state = store.getState();
+    return c.json({
+      ok: true as const,
+      startedAt: state.startedAt,
+      refreshedAt: state.refreshedAt,
+      collectors: state.collectorStatus,
+    });
+  });
+
+  router.openapi(defineRoute(SystemRouteKey.STATUS), (c) => {
+    const state = store.getState();
+    const view = buildSessionView(state.sessions, config);
+    return c.json({
+      counts: view.counts,
+      collectorStatus: state.collectorStatus,
+      generatedAt: state.refreshedAt,
+    });
+  });
+
+  router.openapi(defineRoute(SystemRouteKey.CONFIG), (c) => {
+    const redacted = {
+      ...config,
+      api: { ...config.api, bearerToken: config.api.bearerToken ? "[redacted]" : undefined },
+      mcp: { ...config.mcp, bearerToken: config.mcp.bearerToken ? "[redacted]" : undefined },
+    };
+    return c.json({ config: redacted });
+  });
+
+  router.get("/events", (c) => {
+    const state = store.getState();
+    const clientId = Math.random().toString(36).slice(2, 8);
+
+    return streamSSE(c, async (stream) => {
+      logger.info("api", "SSE client connected", { event: "sse.client_connected", clientId });
+
+      await stream.writeSSE({
+        data: JSON.stringify({ type: "state:initial", data: state }),
+      });
+
+      let keepaliveTimer: ReturnType<typeof setInterval> | undefined;
+      let closed = false;
+
+      const cleanup = () => {
+        if (closed) return;
+        closed = true;
+        if (keepaliveTimer) clearInterval(keepaliveTimer);
+        unsubscribe();
+        logger.info("api", "SSE client disconnected", { event: "sse.client_disconnected", clientId });
+      };
+
+      const unsubscribe = store.onEvent((event) => {
+        if (closed) return;
+        stream.writeSSE({
+          event: event.type,
+          data: JSON.stringify(event),
+        }).catch((error) => {
+          logger.debug("api", "SSE write failed, closing", {
+            event: "sse.write_failed",
+            clientId,
+            errorMessage: error instanceof Error ? error.message : String(error),
+          });
+          cleanup();
+        });
+      });
+
+      if (config.api.sseKeepaliveMs > 0) {
+        keepaliveTimer = setInterval(() => {
+          if (closed) return;
+          stream.write(":keepalive\n\n").catch((error) => {
+            logger.debug("api", "SSE keepalive failed, closing", {
+              event: "sse.keepalive_failed",
+              clientId,
+              errorMessage: error instanceof Error ? error.message : String(error),
+            });
+            cleanup();
+          });
+        }, config.api.sseKeepaliveMs);
+      }
+
+      stream.onAbort(() => {
+        cleanup();
+      });
+
+      // Keep the SSE stream alive indefinitely; cleanup runs via onAbort.
+      await new Promise(() => {});
+    });
+  });
+
+  return router;
+}

package/src/api/routes/usage.ts

@@ -0,0 +1,15 @@
+import { OpenAPIHono } from "@hono/zod-openapi";
+import type { DaemonStore } from "../../daemon/store";
+import { UsageRouteKey } from "../docs/usage.keys";
+import { defineRoute } from "../lib/route";
+
+export function createUsageRouter(store: DaemonStore): OpenAPIHono {
+  const router = new OpenAPIHono();
+
+  router.openapi(defineRoute(UsageRouteKey.GET_USAGE), (c) => {
+    const state = store.getState().usage;
+    return c.json(state);
+  });
+
+  return router;
+}