@scrylog/cli 0.1.0

package/src/daemon/index.ts

@@ -0,0 +1,207 @@
+#!/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

@@ -0,0 +1,86 @@
+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 });
+      }
+    }
+  }
+}