@scrylog/cli 0.1.0

package/src/shared/config.ts

@@ -0,0 +1,478 @@
+import { existsSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import type { LogFormat, LogLevel } from "./logger";
+import { ensureConfigDir, ensureParentDir, getDaemonLogPath, getDefaultConfigPath, getLegacyConfigPath } from "./paths";
+import { getHooksDir, IS_WINDOWS } from "./platform";
+
+// ── Config schema ─────────────────────────────────────────────────────────────
+
+export interface DaemonConfig {
+  /** Interval in ms between tmux/process collection cycles (default: 10000) */
+  pollIntervalMs: number;
+  /** Override Unix socket path for local IPC on macOS/Linux */
+  socketPath?: string;
+  /** Timeout in ms for daemon-owned external commands (default: 5000) */
+  commandTimeoutMs: number;
+  /** Timeout in ms for daemon-owned network requests (default: 10000) */
+  networkTimeoutMs: number;
+  /** Minimum log level written to stderr (default: "info") */
+  logLevel: LogLevel;
+  /** stderr log format (default: "auto") */
+  logFormat: LogFormat;
+  /** Whether scrylogd writes its own JSONL log file (default: true) */
+  logFileEnabled: boolean;
+  /** Path to the JSONL daemon log file */
+  logFilePath: string;
+  /** Max active log file size in bytes before rotation */
+  logFileMaxBytes: number;
+  /** Number of log files to retain including the active file */
+  logFileMaxFiles: number;
+  /** Legacy API TCP port retained for config compatibility. */
+  port?: number;
+  /** Legacy API TCP host retained for config compatibility. */
+  host?: string;
+}
+
+export interface ApiConfig {
+  /** Whether to expose the REST API on TCP (default: true on non-Windows) */
+  tcpEnabled: boolean;
+  /** Hostname for the TCP API listener (default: "127.0.0.1") */
+  host: string;
+  /** TCP port for the REST API listener (default: 7788) */
+  port: number;
+  /** Bearer token for API HTTP auth (required for remote access) */
+  bearerToken?: string;
+  /** SSE keepalive comment-frame interval in ms; 0 disables keepalive (default: 15000) */
+  sseKeepaliveMs: number;
+}
+
+export interface OpenCodeConfig {
+  /** Which OpenCode ingestion path to use (default: "hooks") */
+  mode: "hooks" | "sse";
+  /** Explicit list of OpenCode instance URLs to monitor (auto-discover if empty) */
+  instances: string[];
+  /** Whether to enable auto-discovery via process scanning (default: true) */
+  autoDiscover: boolean;
+}
+
+export interface ClaudeConfig {
+  /** Override path to ~/.claude directory (default: auto-detected) */
+  claudeDir?: string;
+  /** Enable hooks integration for enriched data (default: false) */
+  hooksEnabled: boolean;
+  /** Directory where hook scripts write their output (default: /tmp/scrylog-claude-hooks) */
+  hooksDir: string;
+}
+
+export interface CodexConfig {
+  /** Override path to ~/.codex directory (default: auto-detect, respects $CODEX_HOME) */
+  codexDir?: string;
+  /** Enable hooks integration for enriched data (default: false) */
+  hooksEnabled: boolean;
+  /** Directory where hook scripts write their output (default: /tmp/scrylog-codex-hooks) */
+  hooksDir: string;
+}
+
+export interface TmuxConfig {
+  /** Number of lines to capture for preview (default: 50) */
+  previewLines: number;
+  /** Number of lines to capture for detail view (default: 200) */
+  detailLines: number;
+}
+
+export interface TuiConfig {
+  /** Refresh interval in ms for polling-based updates (default: 5000) */
+  refreshMs: number;
+  /** Whether to show standalone sessions section (default: true) */
+  showStandalone: boolean;
+  /** Whether to connect to daemon via SSE for push updates (default: true) */
+  usePushUpdates: boolean;
+  /** Hide standalone sessions with no activity in the last N hours (default: 6, 0 = show all) */
+  standaloneMaxAgeHours: number;
+  /** Debounce window in ms for coalescing push-event bursts into a single refresh (default: 120, 0 = disabled) */
+  pushDebounceMs: number;
+}
+
+export interface McpConfig {
+  /** Whether the local stdio MCP binary should be allowed (default: true) */
+  stdioEnabled: boolean;
+  /** Whether to expose MCP over HTTP (default: false) */
+  httpEnabled: boolean;
+  /** Host for the MCP HTTP listener (default: 127.0.0.1) */
+  host: string;
+  /** Port for the MCP HTTP transport (default: 7789) */
+  port: number;
+  /** Bearer token for MCP HTTP auth (required for remote access) */
+  bearerToken?: string;
+}
+
+export interface CorsConfig {
+  /** Whether to send CORS headers on API responses (default: false) */
+  enabled: boolean;
+  /** Allowed origins — use ["*"] for public, or explicit URLs (default: []) */
+  origins: string[];
+  /** Allowed HTTP methods (default: ["GET", "POST", "OPTIONS"]) */
+  methods: string[];
+  /** Allowed request headers (default: ["Content-Type", "Authorization"]) */
+  allowedHeaders: string[];
+  /** Whether to expose headers to the browser (default: []) */
+  exposedHeaders: string[];
+  /** Whether to include credentials in CORS requests (default: false) */
+  credentials: boolean;
+  /** Preflight cache duration in seconds (default: 600) */
+  maxAge: number;
+}
+
+export interface UsageClaudeConfig {
+  /** Explicit data source override (default: "auto") */
+  dataSource: "auto" | "oauth" | "web" | "cli";
+  /** Whether to enrich OAuth/CLI with Web API extras (default: true) */
+  webExtrasEnabled: boolean;
+}
+
+export interface UsageCodexConfig {
+  /** Explicit data source override (default: "auto") */
+  dataSource: "auto" | "oauth";
+  /** Override for ChatGPT API base URL (reads from ~/.codex/config.toml if not set) */
+  chatgptBaseUrl?: string;
+}
+
+export interface UsageOpenCodeGoConfig {
+  /** Server function ID for workspace resolution (default: hardcoded) */
+  serverFnId: string;
+}
+
+export interface UsageConfig {
+  /** Whether usage collection is enabled (default: true) */
+  enabled: boolean;
+  /** Poll interval in ms (default: 300000 = 5 minutes) */
+  pollIntervalMs: number;
+  /** Which providers to poll (default: ["claude", "opencode-go"]) */
+  providers: string[];
+  claude: UsageClaudeConfig;
+  codex: UsageCodexConfig;
+  opencodeGo: UsageOpenCodeGoConfig;
+}
+
+export interface RetentionConfig {
+  /** Maximum sessions retained in memory before pruning inactive oldest sessions */
+  maxSessions: number;
+  /** Maximum inactive standalone session age in hours (0 = disabled) */
+  standaloneMaxAgeHours: number;
+  /** TTL for excluded Claude local-command IDs in hours */
+  localCommandTtlHours: number;
+  /** Maximum entries retained by bounded in-memory caches */
+  cacheMaxEntries: number;
+  /** Maximum Claude transcript bytes to parse from the tail of large files */
+  transcriptMaxBytes: number;
+}
+
+export interface ScrylogConfig {
+  daemon: DaemonConfig;
+  api: ApiConfig;
+  cors: CorsConfig;
+  opencode: OpenCodeConfig;
+  claude: ClaudeConfig;
+  codex: CodexConfig;
+  tmux: TmuxConfig;
+  tui: TuiConfig;
+  mcp: McpConfig;
+  usage: UsageConfig;
+  retention: RetentionConfig;
+}
+
+// ── Defaults ──────────────────────────────────────────────────────────────────
+
+export const CONFIG_DEFAULTS: ScrylogConfig = {
+  daemon: {
+    pollIntervalMs: 10_000,
+    commandTimeoutMs: 5_000,
+    networkTimeoutMs: 10_000,
+    logLevel: "info",
+    logFormat: "auto",
+    logFileEnabled: true,
+    logFilePath: getDaemonLogPath(),
+    logFileMaxBytes: 5 * 1024 * 1024,
+    logFileMaxFiles: 3,
+  },
+  api: {
+    tcpEnabled: IS_WINDOWS,
+    host: "127.0.0.1",
+    port: 7788,
+    sseKeepaliveMs: 15_000,
+  },
+  cors: {
+    enabled: false,
+    origins: [],
+    methods: ["GET", "POST", "OPTIONS"],
+    allowedHeaders: ["Content-Type", "Authorization"],
+    exposedHeaders: [],
+    credentials: false,
+    maxAge: 600,
+  },
+  opencode: {
+    mode: "hooks",
+    instances: [],
+    autoDiscover: true,
+  },
+  claude: {
+    hooksEnabled: false,
+    hooksDir: getHooksDir("claude-hooks"),
+  },
+  codex: {
+    hooksEnabled: false,
+    hooksDir: getHooksDir("codex-hooks"),
+  },
+  tmux: {
+    previewLines: 50,
+    detailLines: 200,
+  },
+  tui: {
+    refreshMs: 5_000,
+    showStandalone: true,
+    usePushUpdates: true,
+    standaloneMaxAgeHours: 6,
+    pushDebounceMs: 120,
+  },
+  mcp: {
+    stdioEnabled: true,
+    httpEnabled: false,
+    host: "127.0.0.1",
+    port: 7789,
+  },
+  usage: {
+    enabled: true,
+    pollIntervalMs: 300_000,
+    providers: ["claude", "opencode-go", "codex"],
+    claude: {
+      dataSource: "auto",
+      webExtrasEnabled: true,
+    },
+    codex: {
+      dataSource: "auto",
+    },
+    opencodeGo: {
+      serverFnId: "def39973159c7f0483d8793a822b8dbb10d067e12c65455fcb4608459ba0234f",
+    },
+  },
+  retention: {
+    maxSessions: 500,
+    standaloneMaxAgeHours: 168,
+    localCommandTtlHours: 72,
+    cacheMaxEntries: 1_000,
+    transcriptMaxBytes: 10 * 1024 * 1024,
+  },
+};
+
+// ── Resolution ────────────────────────────────────────────────────────────────
+
+/** Ordered list of default config file locations to probe */
+export function getDefaultConfigPaths(): string[] {
+  return [getDefaultConfigPath(), getLegacyConfigPath()];
+}
+
+export function getResolvedConfigPath(explicitPath?: string): string {
+  if (explicitPath) {
+    return resolve(explicitPath);
+  }
+  if (process.env.SCRYLOG_CONFIG) {
+    return resolve(process.env.SCRYLOG_CONFIG);
+  }
+  for (const path of getDefaultConfigPaths()) {
+    if (existsSync(path)) {
+      return path;
+    }
+  }
+  return getDefaultConfigPath();
+}
+
+/**
+ * Load and merge config from:
+ * 1. --config flag value
+ * 2. SCRYLOG_CONFIG env var
+ * 3. ~/.config/scrylog/config.json
+ * 4. ~/.scrylog.json
+ * 5. Built-in defaults
+ */
+export function loadConfig(explicitPath?: string): ScrylogConfig {
+  const paths: string[] = [];
+
+  if (explicitPath) {
+    paths.push(resolve(explicitPath));
+  } else if (process.env.SCRYLOG_CONFIG) {
+    paths.push(resolve(process.env.SCRYLOG_CONFIG));
+  } else {
+    paths.push(...getDefaultConfigPaths());
+  }
+
+  for (const path of paths) {
+    if (existsSync(path)) {
+      return loadConfigFile(path);
+    }
+  }
+
+  return { ...CONFIG_DEFAULTS };
+}
+
+function loadConfigFile(path: string): ScrylogConfig {
+  const raw = readConfigOverride(path);
+  if (!raw) {
+    return { ...CONFIG_DEFAULTS };
+  }
+
+  return normalizeConfig(raw);
+}
+
+export function readConfigOverride(path: string): PlainObject | null {
+  let raw: unknown;
+
+  try {
+    const content = readFileSync(path, "utf8");
+    raw = JSON.parse(content);
+  } catch (error) {
+    process.stderr.write(
+      `[scrylog] Warning: could not parse config file ${path}: ${error instanceof Error ? error.message : String(error)}\n`,
+    );
+    return null;
+  }
+
+  if (!raw || typeof raw !== "object") {
+    return null;
+  }
+
+  return raw as PlainObject;
+}
+
+export function normalizeConfig(raw: PlainObject): ScrylogConfig {
+  const merged = deepMerge(CONFIG_DEFAULTS as unknown as PlainObject, raw as Partial<PlainObject>) as unknown as ScrylogConfig;
+  return normalizeOperationalConfig(applyLegacyCompatibility(merged, raw));
+}
+
+export function writeConfig(config: ScrylogConfig, explicitPath?: string): string {
+  const path = getResolvedConfigPath(explicitPath);
+  ensureConfigDir();
+  ensureParentDir(path);
+  const tempPath = `${path}.tmp`;
+  writeFileSync(tempPath, `${JSON.stringify(config, null, 2)}\n`, "utf8");
+  renameSync(tempPath, path);
+  return path;
+}
+
+export function updateConfig(
+  updater: (current: ScrylogConfig) => ScrylogConfig,
+  explicitPath?: string,
+): { path: string; config: ScrylogConfig } {
+  const path = getResolvedConfigPath(explicitPath);
+  const current = existsSync(path) ? loadConfig(path) : { ...CONFIG_DEFAULTS };
+  const updated = updater(current);
+  writeConfig(updated, path);
+  return { path, config: updated };
+}
+
+// ── Deep merge ────────────────────────────────────────────────────────────────
+
+type PlainObject = Record<string, unknown>;
+
+function isPlainObject(value: unknown): value is PlainObject {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export function deepMerge<T extends PlainObject>(base: T, override: Partial<T>): T {
+  const result: PlainObject = { ...base };
+
+  for (const key of Object.keys(override)) {
+    const baseValue = result[key];
+    const overrideValue = (override as PlainObject)[key];
+
+    if (isPlainObject(baseValue) && isPlainObject(overrideValue)) {
+      result[key] = deepMerge(baseValue, overrideValue);
+    } else if (overrideValue !== undefined) {
+      result[key] = overrideValue;
+    }
+  }
+
+  return result as T;
+}
+
+function applyLegacyCompatibility(config: ScrylogConfig, raw: PlainObject): ScrylogConfig {
+  const rawDaemon = isPlainObject(raw["daemon"]) ? raw["daemon"] : undefined;
+  const rawApi = isPlainObject(raw["api"]) ? raw["api"] : undefined;
+  const rawMcp = isPlainObject(raw["mcp"]) ? raw["mcp"] : undefined;
+
+  const next: ScrylogConfig = {
+    ...config,
+    api: { ...config.api },
+    daemon: { ...config.daemon },
+    mcp: { ...config.mcp },
+  };
+
+  if (!rawApi && rawDaemon) {
+    const legacyHost = typeof rawDaemon["host"] === "string" ? rawDaemon["host"] : undefined;
+    const legacyPort = typeof rawDaemon["port"] === "number" ? rawDaemon["port"] : undefined;
+    if (legacyHost) next.api.host = legacyHost;
+    if (legacyPort !== undefined) next.api.port = legacyPort;
+    if (legacyHost || legacyPort !== undefined) {
+      next.api.tcpEnabled = legacyPort === 0 ? false : true;
+    }
+  }
+
+  if (rawMcp && rawMcp["httpEnabled"] === undefined) {
+    const legacyPort = typeof rawMcp["port"] === "number" ? rawMcp["port"] : undefined;
+    const legacyHost = typeof rawMcp["host"] === "string" ? rawMcp["host"] : undefined;
+    const legacyToken = typeof rawMcp["bearerToken"] === "string" ? rawMcp["bearerToken"] : undefined;
+    if (legacyHost) next.mcp.host = legacyHost;
+    if (legacyPort !== undefined) next.mcp.port = legacyPort;
+    if (legacyToken) next.mcp.bearerToken = legacyToken;
+    if (legacyHost || legacyPort !== undefined || legacyToken) {
+      next.mcp.httpEnabled = true;
+    }
+  }
+
+  return next;
+}
+
+function normalizeOperationalConfig(config: ScrylogConfig): ScrylogConfig {
+  return {
+    ...config,
+    daemon: {
+      ...config.daemon,
+      pollIntervalMs: clampNumber(config.daemon.pollIntervalMs, 1_000, 300_000, CONFIG_DEFAULTS.daemon.pollIntervalMs),
+      commandTimeoutMs: clampNumber(config.daemon.commandTimeoutMs, 1_000, 120_000, CONFIG_DEFAULTS.daemon.commandTimeoutMs),
+      networkTimeoutMs: clampNumber(config.daemon.networkTimeoutMs, 1_000, 120_000, CONFIG_DEFAULTS.daemon.networkTimeoutMs),
+      logFileMaxBytes: clampNumber(config.daemon.logFileMaxBytes, 0, 100 * 1024 * 1024, CONFIG_DEFAULTS.daemon.logFileMaxBytes),
+      logFileMaxFiles: clampNumber(config.daemon.logFileMaxFiles, 1, 20, CONFIG_DEFAULTS.daemon.logFileMaxFiles),
+    },
+    api: {
+      ...config.api,
+      sseKeepaliveMs: clampNumber(config.api.sseKeepaliveMs, 0, 120_000, CONFIG_DEFAULTS.api.sseKeepaliveMs),
+    },
+    tmux: {
+      ...config.tmux,
+      previewLines: clampNumber(config.tmux.previewLines, 0, 500, CONFIG_DEFAULTS.tmux.previewLines),
+      detailLines: clampNumber(config.tmux.detailLines, 0, 5_000, CONFIG_DEFAULTS.tmux.detailLines),
+    },
+    tui: {
+      ...config.tui,
+      refreshMs: clampNumber(config.tui.refreshMs, 500, 300_000, CONFIG_DEFAULTS.tui.refreshMs),
+      standaloneMaxAgeHours: clampNumber(config.tui.standaloneMaxAgeHours, 0, 8_760, CONFIG_DEFAULTS.tui.standaloneMaxAgeHours),
+      pushDebounceMs: clampNumber(config.tui.pushDebounceMs, 0, 2_000, CONFIG_DEFAULTS.tui.pushDebounceMs),
+    },
+    usage: {
+      ...config.usage,
+      pollIntervalMs: clampNumber(config.usage.pollIntervalMs, 60_000, 3_600_000, CONFIG_DEFAULTS.usage.pollIntervalMs),
+    },
+    retention: {
+      ...config.retention,
+      maxSessions: clampNumber(config.retention.maxSessions, 0, 100_000, CONFIG_DEFAULTS.retention.maxSessions),
+      standaloneMaxAgeHours: clampNumber(config.retention.standaloneMaxAgeHours, 0, 8_760, CONFIG_DEFAULTS.retention.standaloneMaxAgeHours),
+      localCommandTtlHours: clampNumber(config.retention.localCommandTtlHours, 1, 8_760, CONFIG_DEFAULTS.retention.localCommandTtlHours),
+      cacheMaxEntries: clampNumber(config.retention.cacheMaxEntries, 10, 100_000, CONFIG_DEFAULTS.retention.cacheMaxEntries),
+      transcriptMaxBytes: clampNumber(config.retention.transcriptMaxBytes, 64 * 1024, 100 * 1024 * 1024, CONFIG_DEFAULTS.retention.transcriptMaxBytes),
+    },
+  };
+}
+
+function clampNumber(value: number, min: number, max: number, fallback: number): number {
+  if (!Number.isFinite(value)) return fallback;
+  return Math.min(max, Math.max(min, Math.trunc(value)));
+}

package/src/shared/ipc.ts

@@ -0,0 +1,80 @@
+import { join } from "node:path";
+import { IS_WINDOWS, getUserId } from "./platform";
+
+/**
+ * @deprecated Import IS_WINDOWS and getUserId from `shared/platform.ts` instead.
+ * Re-exported here for backward compatibility during the migration.
+ */
+export { IS_WINDOWS, getUserId };
+
+/**
+ * Return the Unix socket path for the daemon.
+ * Includes the current user's uid so multiple users on the same host don't conflict.
+ */
+export function getSocketPath(override?: string): string {
+  if (override) {
+    return override;
+  }
+
+  const uid = getUserId();
+  return join("/tmp", `scrylog-${uid}.sock`);
+}
+
+/**
+ * Build the base URL used for daemon HTTP connections.
+ * - On macOS/Linux: HTTP over Unix socket via the `unix://` path convention
+ * - On Windows (or when TCP is forced): regular TCP URL
+ */
+export function getDaemonUrl(options: {
+  host: string;
+  port: number;
+  socketPath?: string;
+  forceTcp?: boolean;
+}): string {
+  if (!IS_WINDOWS && !options.forceTcp) {
+    return `http://localhost`;
+  }
+
+  return `http://${options.host}:${options.port}`;
+}
+
+/**
+ * Create a `fetch` function that routes requests over the Unix socket.
+ * Falls back to a plain `fetch` pointing at the TCP address on Windows.
+ * Injects an Authorization header when bearerToken is provided.
+ */
+export function createDaemonFetch(options: {
+  host: string;
+  port: number;
+  socketPath?: string;
+  forceTcp?: boolean;
+  bearerToken?: string;
+}): (input: string | URL | Request, init?: RequestInit) => Promise<Response> {
+  const headers: Record<string, string> = options.bearerToken
+    ? { Authorization: `Bearer ${options.bearerToken}` }
+    : {};
+
+  if (IS_WINDOWS || options.forceTcp) {
+    const base = `http://${options.host}:${options.port}`;
+    return (input, init) => {
+      const url = typeof input === "string" && input.startsWith("/") ? `${base}${input}` : input;
+      return fetch(url, {
+        ...init,
+        headers: { ...headers, ...(init?.headers ?? {}) },
+      });
+    };
+  }
+
+  const socketPath = options.socketPath ?? getSocketPath();
+
+  // Bun supports Unix socket via `unix` field in fetch options
+  return (input, init) => {
+    const url = typeof input === "string" && input.startsWith("/") ? `http://localhost${input}` : input;
+    // @ts-ignore -- Bun-specific `unix` option not in standard types
+    return fetch(url, {
+      ...init,
+      unix: socketPath,
+      headers: { ...headers, ...(init?.headers ?? {}) },
+    });
+  };
+}