@scrylog/cli 0.3.0 → 0.3.1

package/src/shared/logger.ts

@@ -1,248 +0,0 @@
-import { appendFileSync, existsSync, mkdirSync, renameSync, statSync, unlinkSync } from "node:fs";
-import { dirname, extname, join, basename } from "node:path";
-import { homedir } from "node:os";
-
-// ── Log levels ─────────────────────────────────────────────────────────────────
-
-export type LogLevel = "debug" | "info" | "warn" | "error";
-export type LogFormat = "auto" | "pretty" | "json";
-export type LoggerWriter = (line: string) => void;
-
-export interface LoggerOptions {
-  level: LogLevel;
-  format?: LogFormat;
-  file?: {
-    enabled: boolean;
-    path: string;
-    maxBytes: number;
-    maxFiles: number;
-  };
-  writer?: LoggerWriter;
-}
-
-const LEVEL_RANK: Record<LogLevel, number> = {
-  debug: 0,
-  info: 1,
-  warn: 2,
-  error: 3,
-};
-
-const LEVEL_LABEL: Record<LogLevel, string> = {
-  debug: "DBG",
-  info: "INF",
-  warn: "WRN",
-  error: "ERR",
-};
-
-const LEVEL_COLOR: Record<LogLevel, string> = {
-  debug: "\x1b[2m",   // dim
-  info:  "\x1b[36m",  // cyan
-  warn:  "\x1b[33m",  // yellow
-  error: "\x1b[31m",  // red
-};
-const ANSI_RESET = "\x1b[0m";
-
-// ── Logger ─────────────────────────────────────────────────────────────────────
-
-export class Logger {
-  private readonly minLevel: LogLevel;
-  private readonly format: LogFormat;
-  private readonly file?: NonNullable<LoggerOptions["file"]>;
-  private readonly writer: LoggerWriter;
-
-  constructor(optionsOrLevel: LoggerOptions | LogLevel) {
-    const options = typeof optionsOrLevel === "string" ? { level: optionsOrLevel } : optionsOrLevel;
-    this.minLevel = options.level;
-    this.format = options.format ?? "auto";
-    this.file = options.file?.enabled ? options.file : undefined;
-    this.writer = options.writer ?? ((line) => process.stderr.write(line + "\n"));
-  }
-
-  debug(source: string, message: string, data?: Record<string, unknown>): void {
-    this.write("debug", source, message, data);
-  }
-
-  info(source: string, message: string, data?: Record<string, unknown>): void {
-    this.write("info", source, message, data);
-  }
-
-  warn(source: string, message: string, data?: Record<string, unknown>): void {
-    this.write("warn", source, message, data);
-  }
-
-  error(source: string, message: string, data?: Record<string, unknown>): void {
-    this.write("error", source, message, data);
-  }
-
-  private write(level: LogLevel, source: string, message: string, data?: Record<string, unknown>): void {
-    if (LEVEL_RANK[level] < LEVEL_RANK[this.minLevel]) return;
-
-    const now = new Date();
-    const isoTs = now.toISOString();
-    const hh = String(now.getHours()).padStart(2, "0");
-    const mm = String(now.getMinutes()).padStart(2, "0");
-    const ss = String(now.getSeconds()).padStart(2, "0");
-    const ms = String(now.getMilliseconds()).padStart(3, "0");
-    const ts = `${hh}:${mm}:${ss}.${ms}`;
-    const label = LEVEL_LABEL[level];
-
-    const { event, fields } = splitEventData(sanitizeData(data));
-    const dataPart = formatPrettyData(fields);
-
-    const isTTY = process.stderr.isTTY === true;
-    const resolvedFormat = this.format === "auto" ? (isTTY ? "pretty" : "json") : this.format;
-    let line: string;
-
-    if (resolvedFormat === "json") {
-      line = JSON.stringify({
-        ts: isoTs,
-        level,
-        source,
-        ...(event ? { event } : {}),
-        msg: message,
-        ...(Object.keys(fields).length > 0 ? { data: fields } : {}),
-      });
-    } else if (level === "debug") {
-      // Whole line dimmed — visually recessive, won't distract from important logs
-      line = `${LEVEL_COLOR.debug}[${ts}] [${label}] [${source}]${event ? ` ${event}` : ""} ${message}${dataPart}${ANSI_RESET}`;
-    } else if (level === "info") {
-      // Only the label colored — clean, easy to scan
-      line = `[${ts}] ${LEVEL_COLOR.info}[${label}]${ANSI_RESET} [${source}]${event ? ` ${event}` : ""} ${message}${dataPart}`;
-    } else {
-      // warn / error — whole line colored so nothing is missed
-      line = `${LEVEL_COLOR[level]}[${ts}] [${label}] [${source}]${event ? ` ${event}` : ""} ${message}${dataPart}${ANSI_RESET}`;
-    }
-
-    this.writer(line);
-
-    if (this.file) {
-      const fileFields = fields;
-      const jsonLine = JSON.stringify({
-        ts: isoTs,
-        level,
-        source,
-        ...(event ? { event } : {}),
-        msg: message,
-        ...(Object.keys(fileFields).length > 0 ? { data: fileFields } : {}),
-      });
-      writeJsonLineToFile(this.file, jsonLine);
-    }
-  }
-}
-
-export function createLogger(optionsOrLevel: LoggerOptions | LogLevel): Logger {
-  return new Logger(optionsOrLevel);
-}
-
-/** Parse a log level string, falling back to the default if invalid. */
-export function parseLogLevel(value: string | undefined, fallback: LogLevel = "info"): LogLevel {
-  if (value === "debug" || value === "info" || value === "warn" || value === "error") {
-    return value;
-  }
-  return fallback;
-}
-
-/** Parse a log format string, falling back to the default if invalid. */
-export function parseLogFormat(value: string | undefined, fallback: LogFormat = "auto"): LogFormat {
-  if (value === "auto" || value === "pretty" || value === "json") {
-    return value;
-  }
-  return fallback;
-}
-
-/** Singleton noop logger for use where no logger is injected. */
-export const NOOP_LOGGER = new Logger("error" as LogLevel);
-// Override write to do nothing — used in tests / non-daemon contexts
-(NOOP_LOGGER as unknown as { write: () => void }).write = () => {};
-
-function splitEventData(data: Record<string, unknown> | undefined): { event?: string; fields: Record<string, unknown> } {
-  if (!data) return { fields: {} };
-  const { event, ...rest } = data;
-  return {
-    ...(typeof event === "string" && event.length > 0 ? { event } : {}),
-    fields: rest,
-  };
-}
-
-function formatPrettyData(data: Record<string, unknown>): string {
-  if (Object.keys(data).length === 0) return "";
-  const pairs = Object.entries(data)
-    .map(([k, v]) => `${k}=${typeof v === "string" ? v : JSON.stringify(v)}`)
-    .join(" ");
-  return `  ${pairs}`;
-}
-
-function sanitizeData(data: Record<string, unknown> | undefined): Record<string, unknown> | undefined {
-  if (!data) return undefined;
-  const sanitized: Record<string, unknown> = {};
-  for (const [key, value] of Object.entries(data)) {
-    sanitized[key] = sanitizeValue(key, value);
-  }
-  return sanitized;
-}
-
-function sanitizeValue(key: string, value: unknown): unknown {
-  if (value === null || value === undefined) return value;
-  if (typeof value === "string") return sanitizeString(key, value);
-  if (Array.isArray(value)) return value.map((item) => sanitizeValue(key, item));
-  if (typeof value === "object") {
-    const out: Record<string, unknown> = {};
-    for (const [childKey, childValue] of Object.entries(value)) {
-      out[childKey] = sanitizeValue(childKey, childValue);
-    }
-    return out;
-  }
-  return value;
-}
-
-function sanitizeString(key: string, value: string): string {
-  if (/authorization|token|secret|password|bearer/i.test(key)) return "[redacted]";
-  let next = value.replace(new RegExp(escapeRegExp(homedir()), "g"), "~");
-  next = next.replace(/(Authorization:\s*Bearer\s+)[^\s]+/gi, "$1[redacted]");
-  next = next.replace(/(Bearer\s+)[A-Za-z0-9._~+\-/]+=*/g, "$1[redacted]");
-  next = next.replace(/([?&](?:token|access_token|api_key|key|secret|password)=)[^&\s]+/gi, "$1[redacted]");
-  next = next.replace(/(https?:\/\/[^\s?]+)\?[^\s]+/gi, "$1?[redacted]");
-  return next;
-}
-
-function writeJsonLineToFile(file: NonNullable<LoggerOptions["file"]>, line: string): void {
-  try {
-    mkdirSync(dirname(file.path), { recursive: true });
-    rotateIfNeeded(file);
-    appendFileSync(file.path, `${line}\n`, "utf8");
-  } catch {
-    // Logging must never crash the daemon.
-  }
-}
-
-function rotateIfNeeded(file: NonNullable<LoggerOptions["file"]>): void {
-  if (file.maxBytes <= 0 || !existsSync(file.path)) return;
-  const size = statSync(file.path).size;
-  if (size < file.maxBytes) return;
-
-  const maxFiles = Math.max(1, file.maxFiles);
-  const rotatedCount = maxFiles - 1;
-  if (rotatedCount <= 0) {
-    unlinkSync(file.path);
-    return;
-  }
-
-  const oldest = rotatedPath(file.path, rotatedCount);
-  if (existsSync(oldest)) unlinkSync(oldest);
-
-  for (let index = rotatedCount - 1; index >= 1; index--) {
-    const from = rotatedPath(file.path, index);
-    if (existsSync(from)) renameSync(from, rotatedPath(file.path, index + 1));
-  }
-  renameSync(file.path, rotatedPath(file.path, 1));
-}
-
-function rotatedPath(path: string, index: number): string {
-  const ext = extname(path);
-  const base = basename(path, ext);
-  return join(dirname(path), `${base}.${index}${ext}`);
-}
-
-function escapeRegExp(value: string): string {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}

package/src/shared/paths.ts

@@ -1,73 +0,0 @@
-import { mkdirSync } from "node:fs";
-import { homedir, userInfo } from "node:os";
-import { dirname, join } from "node:path";
-
-export function getConfigDir(): string {
-  return join(homedir(), ".config", "scrylog");
-}
-
-export function getDefaultConfigPath(): string {
-  return join(getConfigDir(), "config.json");
-}
-
-export function getLegacyConfigPath(): string {
-  return join(homedir(), ".scrylog.json");
-}
-
-export function getStateDir(): string {
-  return join(homedir(), ".local", "state", "scrylog");
-}
-
-export function getDaemonLogPath(): string {
-  return join(homedir(), ".scrylog", "logs", "scrylogd.log");
-}
-
-export function getServiceLabel(): string {
-  return "com.scrylog.daemon";
-}
-
-export function getLaunchAgentsDir(): string {
-  return join(homedir(), "Library", "LaunchAgents");
-}
-
-export function getLaunchAgentPath(): string {
-  return join(getLaunchAgentsDir(), `${getServiceLabel()}.plist`);
-}
-
-export function getSystemdUserDir(): string {
-  return join(homedir(), ".config", "systemd", "user");
-}
-
-export function getSystemdUnitName(): string {
-  return "scrylogd.service";
-}
-
-export function getSystemdUnitPath(): string {
-  return join(getSystemdUserDir(), getSystemdUnitName());
-}
-
-export function ensureParentDir(path: string): void {
-  const dir = path.endsWith("/") ? path.slice(0, -1) : dirname(path);
-  if (!dir || dir === ".") return;
-  mkdirSync(dir, { recursive: true });
-}
-
-export function ensureConfigDir(): string {
-  const dir = getConfigDir();
-  mkdirSync(dir, { recursive: true });
-  return dir;
-}
-
-export function ensureStateDir(): string {
-  const dir = getStateDir();
-  mkdirSync(dir, { recursive: true });
-  return dir;
-}
-
-export function getUserUid(): number | string {
-  try {
-    return userInfo().uid;
-  } catch {
-    return process.env.USER ?? process.env.USERNAME ?? "default";
-  }
-}

package/src/shared/platform.ts

@@ -1,110 +0,0 @@
-import { homedir, tmpdir, userInfo } from "node:os";
-import { join } from "node:path";
-import { chmodSync, lstatSync, mkdirSync, readFileSync, rmSync } from "node:fs";
-
-/** True on Windows where Unix sockets are not available */
-export const IS_WINDOWS = process.platform === "win32";
-
-/** True on macOS */
-export const IS_MAC = process.platform === "darwin";
-
-/** True on Linux (including WSL) */
-export const IS_LINUX = process.platform === "linux";
-
-/** True when running inside Windows Subsystem for Linux */
-export const IS_WSL = ((): boolean => {
-  if (!IS_LINUX) return false;
-  try {
-    const version = readFileSync("/proc/version", "utf8");
-    return /microsoft|wsl/i.test(version);
-  } catch {
-    return false;
-  }
-})();
-
-/**
- * Resolve the path to an executable using the platform-appropriate command.
- * Prefers Bun.which when available, falling back to `which` on Unix and `where` on Windows.
- */
-export function whichCommand(name: string): string | null {
-  const viaBun = (Bun as typeof Bun & { which?: (name: string) => string | null }).which?.(name);
-  if (viaBun) return viaBun;
-
-  if (IS_WINDOWS) {
-    return spawnAndRead("where", [name]);
-  }
-  return spawnAndRead("which", [name]);
-}
-
-function spawnAndRead(command: string, args: string[]): string | null {
-  try {
-    const proc = Bun.spawnSync([command, ...args], { stdout: "pipe", stderr: "ignore" });
-    const text = new TextDecoder().decode(proc.stdout).trim();
-    return text ? text.split(/\r?\n/)[0] ?? text : null;
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Return the current user's id, used to scope shared /tmp paths so multiple
- * users on the same host don't conflict or collide on the same path.
- */
-export function getUserId(): number | string {
-  try {
-    return userInfo().uid;
-  } catch {
-    // Fallback: use a hash of the username
-    return process.env.USER ?? process.env.USERNAME ?? "default";
-  }
-}
-
-/**
- * Return a stable hooks directory path for the given hook name.
- * On Unix we intentionally avoid os.tmpdir() because macOS per-session temp paths
- * would break rendezvous between independently-launched daemon and hook binaries.
- * The path is scoped by uid so multiple users on the same host don't conflict.
- * On Windows we use os.tmpdir() because %TEMP% is stable per user session and
- * already per-user.
- *
- * This function is pure (no I/O). Callers that need to actually create the
- * directory should use `ensureHooksDirSafe`.
- */
-export function getHooksDir(name: string): string {
-  if (IS_WINDOWS) {
-    return join(tmpdir(), `scrylog-${name}`);
-  }
-  return join("/tmp", `scrylog-${getUserId()}-${name}`);
-}
-
-function isOwnedDirectory(dir: string): boolean {
-  const stat = lstatSync(dir);
-  return stat.isDirectory() && stat.uid === process.getuid?.();
-}
-
-/**
- * Ensure `dir` exists and, on Unix, is a real directory (not a symlink)
- * owned by the current user, tightening its mode to 0700. A pre-existing
- * path that isn't a directory we own — e.g. a symlink or a directory
- * planted by another local user on a shared host — is untrusted: it is
- * removed and recreated rather than written into. A directory we already
- * own is tightened in place (not recreated) so existing session state isn't
- * discarded. Ownership/mode checks are skipped on Windows, where
- * `getHooksDir` already resolves to a per-user temp directory.
- */
-export function ensureHooksDirSafe(dir: string): void {
-  mkdirSync(dir, { recursive: true, mode: 0o700 });
-
-  if (IS_WINDOWS) return;
-
-  if (!isOwnedDirectory(dir)) {
-    rmSync(dir, { recursive: true, force: true });
-    mkdirSync(dir, { recursive: true, mode: 0o700 });
-
-    if (!isOwnedDirectory(dir)) {
-      throw new Error(`Refusing to use untrusted hooks directory: ${dir}`);
-    }
-  }
-
-  chmodSync(dir, 0o700);
-}

package/src/shared/session-exclusions.ts

@@ -1,5 +0,0 @@
-const CLAUDE_PROBE_PATH = /(?:^|[\\/-])codexbar[\\/-]claudeprobe(?:$|[\\/-])/i;
-
-export function isKnownClaudeProbePath(path?: string): boolean {
-  return typeof path === "string" && CLAUDE_PROBE_PATH.test(path);
-}