@scrylog/cli 0.1.0

package/src/tui/client.ts

@@ -0,0 +1,149 @@
+import { createDaemonFetch, getSocketPath } from "../shared/ipc";
+import { IS_WINDOWS } from "../shared/platform";
+import type { ScrylogConfig } from "../shared/config";
+import type { SessionModel, StoreEvent } from "../shared/types";
+import type { SessionListItem, SessionTreeItem, SessionViewCounts } from "../shared/session-view";
+import { flattenSessionTree } from "../shared/session-view";
+
+type FetchFn = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+
+export class DaemonClient {
+  private readonly fetch: FetchFn;
+
+  constructor(config: ScrylogConfig, socketPath?: string) {
+    this.fetch = createDaemonFetch({
+      host: config.api.host,
+      port: config.api.port,
+      socketPath: socketPath ?? (IS_WINDOWS ? undefined : getSocketPath(config.daemon.socketPath)),
+      bearerToken: config.api.bearerToken,
+    });
+  }
+
+  async getStatusSummary(): Promise<{ counts: SessionViewCounts; collectorStatus: Record<string, unknown>; generatedAt: number } | null> {
+    try {
+      const response = await this.fetch("/api/status");
+      if (!response.ok) return null;
+      return await response.json() as { counts: SessionViewCounts; collectorStatus: Record<string, unknown>; generatedAt: number };
+    } catch {
+      return null;
+    }
+  }
+
+  async isHealthy(): Promise<boolean> {
+    try {
+      const response = await this.fetch("/api/health");
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+
+  async getSessions(): Promise<{ sessions: SessionListItem[]; counts: SessionViewCounts; generatedAt: number } | null> {
+    try {
+      const response = await this.fetch("/api/sessions");
+      if (!response.ok) return null;
+      const data = await response.json() as { sessions: SessionTreeItem[]; counts: SessionViewCounts; generatedAt: number };
+      return {
+        sessions: flattenSessionTree(data.sessions),
+        counts: data.counts,
+        generatedAt: data.generatedAt,
+      };
+    } catch {
+      return null;
+    }
+  }
+
+  async getSessionDetail(id: string): Promise<SessionModel | null> {
+    try {
+      const response = await this.fetch(`/api/sessions/${encodeURIComponent(id)}`);
+      if (!response.ok) return null;
+      const data = await response.json() as { session: SessionModel };
+      return data.session;
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Subscribe to daemon SSE events with automatic reconnect.
+   * Returns an unsubscribe function.
+   */
+  subscribeEvents(onEvent: (event: StoreEvent | { type: "connected" } | { type: "disconnected" }) => void): () => void {
+    let aborted = false;
+    const controller = new AbortController();
+    let reconnectTimer: ReturnType<typeof setTimeout> | null = null;
+    let reconnectDelay = 1_000;
+
+    const connect = async () => {
+      if (aborted) return;
+      try {
+        const response = await this.fetch("/api/events", {
+          signal: controller.signal,
+          headers: { Accept: "text/event-stream" },
+        });
+
+        if (!response.ok || !response.body) {
+          if (!aborted) {
+            onEvent({ type: "disconnected" });
+          }
+          return;
+        }
+
+        onEvent({ type: "connected" });
+        reconnectDelay = 1_000; // reset backoff on successful connect
+
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+
+        while (!aborted) {
+          const { value, done } = await reader.read();
+          if (done) break;
+
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split("\n");
+          buffer = lines.pop() ?? "";
+
+          for (const line of lines) {
+            if (line.startsWith("data: ")) {
+              try {
+                const payload = JSON.parse(line.slice(6)) as StoreEvent;
+                onEvent(payload);
+              } catch {
+                // Ignore malformed events
+              }
+            }
+          }
+        }
+      } catch (error) {
+        if (!aborted) {
+          onEvent({ type: "disconnected" });
+        }
+      }
+    };
+
+    const scheduleReconnect = () => {
+      if (aborted || reconnectTimer) return;
+      reconnectTimer = setTimeout(() => {
+        reconnectTimer = null;
+        void connect().then(() => {
+          if (!aborted) scheduleReconnect();
+        });
+      }, reconnectDelay);
+      reconnectDelay = Math.min(reconnectDelay * 1.5, 5_000);
+    };
+
+    void connect().then(() => {
+      if (!aborted) scheduleReconnect();
+    });
+
+    return () => {
+      aborted = true;
+      controller.abort();
+      if (reconnectTimer) {
+        clearTimeout(reconnectTimer);
+        reconnectTimer = null;
+      }
+    };
+  }
+}

package/src/tui/index.ts

@@ -0,0 +1,181 @@
+#!/usr/bin/env bun
+import { loadConfig } from "../shared/config";
+import type { ScrylogConfig } from "../shared/config";
+import { DaemonClient } from "./client";
+import { DashboardApp } from "./app";
+import { getServiceManagerOrThrow } from "../service/manager";
+import type { ServiceStatus } from "../service/manager";
+import {
+  runClaudeHooksInstall,
+  runCodexHooksInstall,
+  runConfigCommand,
+  runDaemonCommand,
+  runDoctor,
+  runLogsCommand,
+  runSetupWizard,
+  runTokenCommand,
+} from "../cli/commands";
+
+function printHelp() {
+  process.stdout.write(`scrylog
+
+Usage:
+  scrylog [--config <path>]
+  scrylog setup [--config <path>]
+  scrylog doctor [--config <path>]
+  scrylog daemon <install|uninstall|start|stop|restart|status> [--config <path>]
+  scrylog config <show|path> [--config <path>]
+  scrylog token <mcp|api|both> <generate|rotate|clear> [--config <path>]
+  scrylog claude hooks install [--config <path>]
+  scrylog codex hooks install [--config <path>]
+  scrylog logs
+
+Options:
+  --config <path>   Load config from an explicit path
+  -h, --help        Show this help text
+
+Notes:
+  Running scrylog with no subcommand launches the TUI dashboard.
+  'scrylog claude hooks install' configures Claude Code to emit lifecycle
+  hooks that scrylog uses for real-time session state tracking.
+  'scrylog codex hooks install' configures Codex CLI to emit lifecycle
+  hooks that scrylog uses for real-time session state tracking.
+`);
+}
+
+function extractGlobalOptions(argv: string[]) {
+  const args = [...argv];
+  let configPath: string | undefined;
+  const configFlagIndex = args.indexOf("--config");
+  if (configFlagIndex >= 0) {
+    configPath = args[configFlagIndex + 1];
+    args.splice(configFlagIndex, configPath ? 2 : 1);
+  }
+  return { args, options: { configPath } };
+}
+
+async function launchTui(configPath?: string): Promise<void> {
+  const config = loadConfig(configPath);
+
+  const client = new DaemonClient(config);
+  if (!(await client.isHealthy())) {
+    printDaemonNotRunning(config, getServiceManagerOrThrow().platform);
+    process.exit(1);
+  }
+
+  const app = new DashboardApp(client, {
+    refreshMs: config.tui.refreshMs,
+    showStandalone: config.tui.showStandalone,
+  }, config);
+
+  app.start();
+}
+
+/**
+ * Print a platform-aware error explaining that the daemon is not running and
+ * listing the commands to verify, start, and inspect it. Exported for testing.
+ */
+export function printDaemonNotRunning(config: ScrylogConfig, platform: ServiceStatus["platform"]): void {
+  const logPath = config.daemon.logFilePath;
+  const hasService = platform === "macos" || platform === "linux";
+
+  process.stderr.write("scrylog: daemon is not running.\n\n");
+  process.stderr.write("Verify:\n");
+  process.stderr.write("  scrylog daemon status\n");
+  process.stderr.write("  scrylog doctor\n\n");
+  process.stderr.write("Start it (pick one):\n");
+  if (hasService) {
+    process.stderr.write("  scrylog daemon start      # user service\n");
+    process.stderr.write("  scrylog daemon install    # if the service is not installed yet\n");
+  }
+  process.stderr.write("  scrylogd                  # foreground\n\n");
+  process.stderr.write(`Logs:\n  scrylog logs\n  ${logPath}\n`);
+
+  if (!hasService) {
+    const note =
+      platform === "wsl"
+        ? "Service management is unavailable (WSL without systemd). Run scrylogd directly or enable systemd in /etc/wsl.conf."
+        : platform === "linux-no-systemd"
+          ? "Service management is unavailable (no systemd user session). Run scrylogd directly."
+          : "Service management is unavailable on this platform. Run scrylogd directly or use Task Scheduler.";
+    process.stderr.write(`\n${note}\n`);
+  }
+}
+
+async function main(): Promise<void> {
+  const { args, options } = extractGlobalOptions(process.argv.slice(2));
+  if (args.includes("--help") || args.includes("-h")) {
+    printHelp();
+    process.exit(0);
+  }
+
+  const [command, subcommand] = args;
+  if (!command) {
+    await launchTui(options.configPath ?? process.env.SCRYLOG_CONFIG);
+    return;
+  }
+
+  if (command === "setup") {
+    await runSetupWizard(options);
+    return;
+  }
+
+  if (command === "doctor") {
+    await runDoctor(options);
+    return;
+  }
+
+  if (command === "daemon") {
+    if (!subcommand) throw new Error("Missing daemon action");
+    await runDaemonCommand(subcommand, options);
+    return;
+  }
+
+  if (command === "config") {
+    if (!subcommand) throw new Error("Missing config action");
+    runConfigCommand(subcommand, options);
+    return;
+  }
+
+  if (command === "token") {
+    if (!subcommand) throw new Error("Missing token target (mcp, api, or both)");
+    const action = args[2];
+    if (!action) throw new Error("Missing token action (generate, rotate, or clear)");
+    const target = subcommand;
+    if (target !== "mcp" && target !== "api" && target !== "both") {
+      throw new Error(`Invalid token target: ${target}. Must be mcp, api, or both.`);
+    }
+    runTokenCommand(target as "mcp" | "api" | "both", action, options);
+    return;
+  }
+
+  if (command === "logs") {
+    await runLogsCommand();
+    return;
+  }
+
+  if (command === "claude") {
+    if (subcommand === "hooks" && args[2] === "install") {
+      await runClaudeHooksInstall(options);
+      return;
+    }
+    throw new Error(`Unknown claude subcommand: ${subcommand ?? "(none)"}`);
+  }
+
+  if (command === "codex") {
+    if (subcommand === "hooks" && args[2] === "install") {
+      await runCodexHooksInstall(options);
+      return;
+    }
+    throw new Error(`Unknown codex subcommand: ${subcommand ?? "(none)"}`);
+  }
+
+  throw new Error(`Unknown command: ${command}`);
+}
+
+if (import.meta.main) {
+  main().catch((err) => {
+    process.stderr.write(`scrylog: fatal: ${err instanceof Error ? err.message : String(err)}\n`);
+    process.exit(1);
+  });
+}

package/src/types.ts

@@ -0,0 +1,113 @@
+export type ToolKind = "opencode" | "claude" | "codex" | "copilotcli" | "shell" | "unknown";
+
+export type PaneState = "working" | "idle" | "waiting-input" | "shell" | "unknown";
+
+export interface SessionInfo {
+  name: string;
+  attached: boolean;
+  windows: number;
+}
+
+export interface TmuxPaneRecord {
+  sessionName: string;
+  windowIndex: number;
+  windowName: string;
+  paneIndex: number;
+  paneId: string;
+  panePid: number;
+  currentCommand: string;
+  currentPath: string;
+  active: boolean;
+  tty: string;
+  title: string;
+  width: number;
+  height: number;
+}
+
+export interface ProjectInfo {
+  displayName: string;
+  compactLabel: string;
+  sourcePath: string;
+  isGitRepository: boolean;
+  gitRootPath?: string;
+  repositoryIdentityPath?: string;
+  branch?: string;
+  isWorktree?: boolean;
+  remoteName?: string;
+  remoteUrl?: string;
+}
+
+export interface EnrichedPaneRecord extends TmuxPaneRecord {
+  project: ProjectInfo;
+}
+
+export interface ProcessInfo {
+  pid: number;
+  ppid: number;
+  state: string;
+  elapsed: string;
+  command: string;
+  comm: string;
+}
+
+export interface DetectionReason {
+  label: string;
+  detail: string;
+}
+
+export interface PaneSample {
+  paneId: string;
+  lines: string[];
+  preview: string;
+}
+
+export interface PaneModel extends EnrichedPaneRecord {
+  processTree: ProcessInfo[];
+  processChain: string[];
+  sample: PaneSample | null;
+  tool: ToolKind;
+  state: PaneState;
+  toolReasons: DetectionReason[];
+  stateReasons: DetectionReason[];
+  summary: string;
+  lastChangedAt: number;
+  stableForMs: number;
+  hasAttention: boolean;
+}
+
+export interface SnapshotError {
+  source: string;
+  message: string;
+}
+
+export interface DashboardSnapshot {
+  sessions: SessionInfo[];
+  panes: PaneModel[];
+  generatedAt: number;
+  errors: SnapshotError[];
+}
+
+export interface FilterOptions {
+  query: string;
+  actionableOnly: boolean;
+  tool: ToolKind | "all";
+  state: PaneState | "all";
+}
+
+export interface SnapshotHistory {
+  tool: ToolKind;
+  state: PaneState;
+  lastFingerprint: string;
+  lastChangedAt: number;
+  stableCount: number;
+}
+
+export interface CollectorOptions {
+  previewLines: number;
+  detailLines: number;
+  refreshMs: number;
+}
+
+export interface AppOptions extends CollectorOptions {
+  selectedPaneId?: string;
+}