@scrylog/cli 0.2.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-view.ts

@@ -1,241 +0,0 @@
-import type { ScrylogConfig } from "./config";
-import type { ProjectInfo, SessionModel, SessionState, SessionTool } from "./types";
-
-export interface SessionListProjectInfo {
-  displayName: string;
-  compactLabel: string;
-  branch?: string;
-  isGitRepository?: boolean;
-  sourcePath?: string;
-  gitRootPath?: string;
-  repositoryIdentityPath?: string;
-}
-
-export interface SessionListTmuxInfo {
-  session: string;
-  window: string;
-  pane: string;
-}
-
-export interface SessionListItem {
-  id: string;
-  source: SessionModel["source"];
-  tool: SessionTool;
-  state: SessionState;
-  summary: string;
-  lastActivity: number;
-  stableForMs?: number;
-  hasAttention?: boolean;
-  detectionSource?: SessionModel["detectionSource"];
-  parentSessionId?: string;
-  project?: SessionListProjectInfo;
-  tmux?: SessionListTmuxInfo;
-  currentPath?: string;
-  activeTool?: string;
-  childCount?: number;
-  activeChildCount?: number;
-}
-
-export interface SessionTreeItem extends SessionListItem {
-  children: SessionListItem[];
-}
-
-export interface SessionViewCounts {
-  total: number;
-  visible: number;
-  rootsVisible: number;
-  childrenVisible: number;
-  byState: Record<SessionState, number>;
-  byTool: Record<SessionTool, number>;
-}
-
-export interface SessionView {
-  counts: SessionViewCounts;
-  sessions: SessionTreeItem[];
-}
-
-function makeStateCounts(): Record<SessionState, number> {
-  return {
-    working: 0,
-    idle: 0,
-    "waiting-input": 0,
-    error: 0,
-    shell: 0,
-    unknown: 0,
-  };
-}
-
-function makeToolCounts(): Record<SessionTool, number> {
-  return {
-    opencode: 0,
-    claude: 0,
-    codex: 0,
-    copilotcli: 0,
-    shell: 0,
-    unknown: 0,
-  };
-}
-
-const CODEX_ROOT_EPHEMERAL_GRACE_MS = 30_000;
-
-function isEphemeralCodexRootSession(session: SessionModel, now: number): boolean {
-  return session.tool === "codex"
-    && session.source === "standalone"
-    && session.detectionSource === "codex-hook"
-    && session.state === "idle"
-    && session.currentPath === "/"
-    && !session.codex?.transcriptPath
-    && !session.parentSessionId
-    && (session.childSessionIds?.length ?? 0) === 0
-    && now - session.lastActivity > CODEX_ROOT_EPHEMERAL_GRACE_MS;
-}
-
-function isCanonicallyVisible(session: SessionModel, config: ScrylogConfig, now: number): boolean {
-  if (session.parentSessionId) {
-    return session.state === "working" || session.state === "waiting-input";
-  }
-
-  if (isEphemeralCodexRootSession(session, now)) {
-    return false;
-  }
-
-  const cutoff = config.tui.standaloneMaxAgeHours > 0
-    ? now - config.tui.standaloneMaxAgeHours * 3_600_000
-    : 0;
-
-  if (cutoff > 0 && session.source === "standalone" && session.lastActivity < cutoff) {
-    return false;
-  }
-
-  return true;
-}
-
-function toProject(project?: ProjectInfo): SessionListProjectInfo | undefined {
-  if (!project) return undefined;
-  return {
-    displayName: project.displayName,
-    compactLabel: project.compactLabel,
-    branch: project.branch,
-    isGitRepository: project.isGitRepository,
-    sourcePath: project.sourcePath,
-    gitRootPath: project.gitRootPath,
-    repositoryIdentityPath: project.repositoryIdentityPath,
-  };
-}
-
-const GRACE_PERIOD_MS = 1500;
-
-function effectiveState(session: SessionModel, activeChildCount: number, now: number): SessionState {
-  if (session.state === "idle" && !session.parentSessionId) {
-    if (activeChildCount > 0) {
-      return "working";
-    }
-    if (session.lastChildActiveAt && (now - session.lastChildActiveAt) < GRACE_PERIOD_MS) {
-      return "working";
-    }
-  }
-  return session.state;
-}
-
-function stableDuration(session: SessionModel, effective: SessionState, now: number): number {
-  if (effective === "working" && session.lastWorkingChangedAt) {
-    return Math.max(0, now - session.lastWorkingChangedAt);
-  }
-  if (session.stateChangedAt) {
-    return Math.max(0, now - session.stateChangedAt);
-  }
-  return session.stableForMs ?? Math.max(0, now - session.lastActivity);
-}
-
-function toListItem(session: SessionModel, childCount: number, activeChildCount: number, now: number): SessionListItem {
-  const effective = effectiveState(session, activeChildCount, now);
-  return {
-    id: session.id,
-    source: session.source,
-    tool: session.tool,
-    state: effective,
-    summary: session.summary,
-    lastActivity: session.lastActivity,
-    stableForMs: stableDuration(session, effective, now),
-    hasAttention: session.hasAttention,
-    detectionSource: session.detectionSource,
-    parentSessionId: session.parentSessionId,
-    project: toProject(session.project),
-    tmux: session.tmux,
-    currentPath: session.currentPath,
-    activeTool: session.activeTool,
-    childCount,
-    activeChildCount,
-  };
-}
-
-export function flattenSessionTree(sessions: SessionTreeItem[]): SessionListItem[] {
-  const flat: SessionListItem[] = [];
-  for (const session of sessions) {
-    const { children: _children, ...root } = session;
-    flat.push(root);
-    flat.push(...session.children);
-  }
-  return flat;
-}
-
-export function buildSessionView(sessions: SessionModel[], config: ScrylogConfig, now = Date.now()): SessionView {
-  const byId = new Map(sessions.map((session) => [session.id, session]));
-  const allChildren = new Map<string, SessionModel[]>();
-  const visibleChildren = new Map<string, SessionModel[]>();
-  const visibleRoots = new Map<string, SessionModel>();
-
-  for (const session of sessions) {
-    if (session.parentSessionId) {
-      const arr = allChildren.get(session.parentSessionId) ?? [];
-      arr.push(session);
-      allChildren.set(session.parentSessionId, arr);
-
-      if (isCanonicallyVisible(session, config, now)) {
-        const visibleArr = visibleChildren.get(session.parentSessionId) ?? [];
-        visibleArr.push(session);
-        visibleChildren.set(session.parentSessionId, visibleArr);
-
-        const parent = byId.get(session.parentSessionId);
-        if (parent) {
-          visibleRoots.set(parent.id, parent);
-        }
-      }
-      continue;
-    }
-
-    if (isCanonicallyVisible(session, config, now)) {
-      visibleRoots.set(session.id, session);
-    }
-  }
-
-  const sortedRoots = [...visibleRoots.values()].sort((a, b) => b.lastActivity - a.lastActivity);
-  const tree: SessionTreeItem[] = sortedRoots.map((root) => {
-    const activeChildren = (visibleChildren.get(root.id) ?? []).sort((a, b) => b.lastActivity - a.lastActivity);
-    const allDirectChildren = allChildren.get(root.id) ?? [];
-    return {
-      ...toListItem(root, allDirectChildren.length, activeChildren.length, now),
-      children: activeChildren.map((child) => toListItem(child, 0, 0, now)),
-    };
-  });
-
-  const flatVisible = flattenSessionTree(tree);
-  const byState = makeStateCounts();
-  const byTool = makeToolCounts();
-  for (const session of flatVisible) {
-    byState[session.state] += 1;
-    byTool[session.tool] += 1;
-  }
-
-  return {
-    counts: {
-      total: sessions.length,
-      visible: flatVisible.length,
-      rootsVisible: tree.length,
-      childrenVisible: flatVisible.filter((session) => Boolean(session.parentSessionId)).length,
-      byState,
-      byTool,
-    },
-    sessions: tree,
-  };
-}