@scrylog/cli 0.2.0 → 0.3.1

package/src/daemon/index.ts

@@ -1,207 +0,0 @@
-#!/usr/bin/env bun
-import { unlinkSync, existsSync } from "node:fs";
-import { loadConfig } from "../shared/config";
-import { getSocketPath } from "../shared/ipc";
-import { IS_WINDOWS } from "../shared/platform";
-import { DaemonStore } from "./store";
-import { Scheduler } from "./scheduler";
-import { TmuxCollector } from "./collectors/tmux";
-import { ProcessCollector } from "./collectors/process";
-import { GitCollector } from "./collectors/git";
-import { OpenCodeCollector } from "./collectors/opencode";
-import { ClaudeCollector } from "./collectors/claude";
-import { CodexCollector } from "./collectors/codex";
-import { OpenCodeDbCollector } from "./collectors/opencode-db";
-import { UsageCollector } from "./collectors/usage";
-import { createApiHandler } from "../api/index";
-import { createMcpHttpHandler } from "../mcp/http-handler";
-import { createLogger, parseLogFormat, parseLogLevel } from "../shared/logger";
-import { parseDaemonArgs } from "./cli";
-
-function printHelp() {
-  process.stdout.write(`scrylogd
-
-Usage:
-  scrylogd [options]
-
-Options:
-  --config <path>       Load config from an explicit path
-  --log-level <level>   Override daemon log level
-  --log-format <format> Override stderr log format (pretty|json)
-  --no-log-file         Disable daemon JSONL file logging for this process
-  -h, --help            Show this help text
-
-Notes:
-  Starts the scrylog daemon, HTTP API, and MCP HTTP listener.
-`);
-}
-
-// ── Parse CLI args ────────────────────────────────────────────────────────────
-
-const args = process.argv.slice(2);
-let cliOptions: ReturnType<typeof parseDaemonArgs>;
-try {
-  cliOptions = parseDaemonArgs(args);
-} catch (error) {
-  process.stderr.write(`scrylogd: ${error instanceof Error ? error.message : String(error)}\n`);
-  process.exit(1);
-}
-
-if (cliOptions.help) {
-  printHelp();
-  process.exit(0);
-}
-const configPath = cliOptions.configPath;
-const logLevelArg = cliOptions.logLevel;
-const logFormatArg = cliOptions.logFormat;
-
-// ── Bootstrap ─────────────────────────────────────────────────────────────────
-
-const config = loadConfig(configPath);
-const logLevel = parseLogLevel(logLevelArg, config.daemon.logLevel);
-const logFormat = parseLogFormat(logFormatArg, config.daemon.logFormat);
-const logger = createLogger({
-  level: logLevel,
-  format: logFormat,
-  file: {
-    enabled: config.daemon.logFileEnabled && cliOptions.logFileEnabled,
-    path: config.daemon.logFilePath,
-    maxBytes: config.daemon.logFileMaxBytes,
-    maxFiles: config.daemon.logFileMaxFiles,
-  },
-});
-const store = new DaemonStore(logger);
-const scheduler = new Scheduler(store, config, logger);
-const processCollector = new ProcessCollector();
-const gitCollector = new GitCollector();
-
-scheduler.register(processCollector);
-scheduler.register(gitCollector);
-scheduler.register(new TmuxCollector(processCollector, gitCollector));
-if (config.opencode.mode === "sse") {
-  scheduler.register(new OpenCodeCollector(gitCollector));
-}
-scheduler.register(new ClaudeCollector(gitCollector));
-scheduler.register(new CodexCollector(gitCollector));
-scheduler.register(new OpenCodeDbCollector(gitCollector));
-if (config.usage.enabled) {
-  scheduler.register(new UsageCollector());
-}
-
-// ── Duplicate-instance detection ──────────────────────────────────────────────
-
-const socketPath = getSocketPath(config.daemon.socketPath);
-const apiTcpEnabled = IS_WINDOWS || config.api.tcpEnabled;
-
-if (IS_WINDOWS) {
-  if (!config.api.tcpEnabled) {
-    logger.warn("daemon", "Windows requires TCP for duplicate detection and API access. Using TCP regardless of config.api.tcpEnabled.", { event: "daemon.tcp_required", platform: "windows" });
-  }
-
-  // Try connecting to an existing daemon via TCP; if it responds, exit
-  try {
-    const probeHeaders: Record<string, string> = config.api.bearerToken
-      ? { Authorization: `Bearer ${config.api.bearerToken}` }
-      : {};
-    const probeUrl = `http://localhost:${config.api.port}/api/health`;
-    const probe = await fetch(probeUrl, { headers: probeHeaders, signal: AbortSignal.timeout(config.daemon.networkTimeoutMs) });
-    if (probe.ok) {
-      logger.info("daemon", "Another daemon is already running. Exiting.", { event: "daemon.duplicate_detected", listener: "tcp", url: probeUrl });
-      process.exit(0);
-    }
-  } catch {
-    // No running daemon — continue
-  }
-} else {
-  // Try connecting to an existing daemon; if it responds, exit
-  try {
-    const probeHeaders: Record<string, string> = config.api.bearerToken
-      ? { Authorization: `Bearer ${config.api.bearerToken}` }
-      : {};
-    // @ts-ignore -- Bun-specific unix option
-    const probe = await fetch("http://localhost/api/health", { unix: socketPath, headers: probeHeaders, signal: AbortSignal.timeout(config.daemon.networkTimeoutMs) });
-    if (probe.ok) {
-      logger.info("daemon", "Another daemon is already running. Exiting.", { event: "daemon.duplicate_detected", socketPath });
-      process.exit(0);
-    }
-  } catch {
-    // No running daemon — clean up stale socket and continue
-    if (existsSync(socketPath)) {
-      try {
-        unlinkSync(socketPath);
-      } catch {
-        // Ignore cleanup errors
-      }
-    }
-  }
-}
-
-// ── Start collectors ──────────────────────────────────────────────────────────
-
-await scheduler.start();
-
-// ── HTTP API handler (shared across Unix socket and TCP) ──────────────────────
-
-const apiHandler = createApiHandler(store, config, logger, gitCollector);
-
-// ── Unix socket listener (macOS/Linux) ────────────────────────────────────────
-
-if (!IS_WINDOWS) {
-  // idleTimeout is not typed on the unix socket variant but is supported at runtime
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  Bun.serve({
-    unix: socketPath,
-    fetch: apiHandler,
-    idleTimeout: 0, // SSE connections must not be dropped on idle
-  } as any);
-  logger.info("daemon", "Unix socket listener started", { event: "daemon.listener_started", listener: "unix", socketPath });
-}
-
-// ── TCP listener ──────────────────────────────────────────────────────────────
-
-if (apiTcpEnabled) {
-  Bun.serve({
-    port: config.api.port,
-    hostname: config.api.host,
-    fetch: apiHandler,
-    idleTimeout: 0, // SSE connections must not be dropped on idle
-  });
-  logger.info("daemon", "HTTP API listener started", { event: "daemon.listener_started", listener: "api", url: `http://${config.api.host}:${config.api.port}` });
-} else {
-  logger.info("daemon", "HTTP API TCP listener disabled", { event: "daemon.listener_disabled", listener: "api" });
-}
-
-// ── MCP HTTP listener (in-daemon) ─────────────────────────────────────────────
-
-const mcpHandler = createMcpHttpHandler(store, config);
-if (mcpHandler) {
-  Bun.serve({
-    port: config.mcp.port,
-    hostname: config.mcp.host,
-    fetch: mcpHandler,
-    idleTimeout: 0, // long-lived MCP connections
-  });
-  logger.info("daemon", "MCP HTTP listener started", { event: "daemon.listener_started", listener: "mcp", url: `http://${config.mcp.host}:${config.mcp.port}` });
-} else {
-  logger.info("daemon", "MCP HTTP listener disabled", { event: "daemon.listener_disabled", listener: "mcp" });
-}
-
-// ── Signal handling ───────────────────────────────────────────────────────────
-
-async function shutdown(signal: string): Promise<void> {
-  logger.info("daemon", "Received signal. Shutting down", { event: "daemon.shutdown", signal });
-  await scheduler.stop();
-  if (!IS_WINDOWS && existsSync(socketPath)) {
-    try {
-      unlinkSync(socketPath);
-    } catch {
-      // Ignore
-    }
-  }
-  process.exit(0);
-}
-
-process.on("SIGTERM", () => void shutdown("SIGTERM"));
-process.on("SIGINT", () => void shutdown("SIGINT"));
-
-logger.info("daemon", "Started", { event: "daemon.started" });

package/src/daemon/scheduler.ts

@@ -1,86 +0,0 @@
-import type { ScrylogConfig } from "../shared/config";
-import type { Logger } from "../shared/logger";
-import type { DaemonStore } from "./store";
-import type { ProcessCollector } from "./collectors/process";
-
-export interface Collector {
-  name: string;
-  /** Called once to start periodic/event-driven collection */
-  start(store: DaemonStore, config: ScrylogConfig, logger: Logger): void | Promise<void>;
-  /** Called on daemon shutdown */
-  stop(): void | Promise<void>;
-}
-
-/**
- * Orchestrates all collectors.
- * Handles lifecycle start/stop and periodic polling intervals.
- */
-export class Scheduler {
-  private collectors: Collector[] = [];
-  private running = false;
-  private retentionTimer?: ReturnType<typeof setInterval>;
-
-  constructor(
-    private readonly store: DaemonStore,
-    private readonly config: ScrylogConfig,
-    private readonly logger: Logger,
-  ) {}
-
-  register(collector: Collector): void {
-    this.collectors.push(collector);
-    if (collector.name === "process" && "processes" in collector) {
-      this.store.registerProcessCollector(collector as unknown as ProcessCollector);
-    }
-  }
-
-  async start(): Promise<void> {
-    if (this.running) {
-      return;
-    }
-
-    this.running = true;
-    this.logger.info("scheduler", "Starting all collectors", { event: "scheduler.collectors_starting", count: this.collectors.length });
-
-    for (const collector of this.collectors) {
-      try {
-        this.store.setCollectorStatus(collector.name, { running: true, lastRunAt: Date.now() });
-        this.logger.debug("scheduler", "Starting collector", { event: "collector.starting", collector: collector.name });
-        await collector.start(this.store, this.config, this.logger);
-      } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        this.logger.warn("scheduler", "Collector failed to start", { event: "collector.start_failed", collector: collector.name, errorMessage: message });
-        this.store.setCollectorStatus(collector.name, { running: false, lastError: message });
-        this.store.reportError(collector.name, message);
-      }
-    }
-
-    this.store.applyRetention(this.config.retention);
-    this.retentionTimer = setInterval(() => {
-      this.store.applyRetention(this.config.retention);
-    }, Math.max(this.config.daemon.pollIntervalMs, 60_000));
-  }
-
-  async stop(): Promise<void> {
-    if (!this.running) {
-      return;
-    }
-
-    this.running = false;
-    this.logger.info("scheduler", "Stopping all collectors", { event: "scheduler.collectors_stopping" });
-    if (this.retentionTimer) {
-      clearInterval(this.retentionTimer);
-      this.retentionTimer = undefined;
-    }
-
-    for (const collector of this.collectors) {
-      try {
-        await collector.stop();
-        this.store.setCollectorStatus(collector.name, { running: false });
-        this.logger.debug("scheduler", "Stopped collector", { event: "collector.stopped", collector: collector.name });
-      } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        this.logger.warn("scheduler", "Collector failed to stop", { event: "collector.stop_failed", collector: collector.name, errorMessage: message });
-      }
-    }
-  }
-}