@scrylog/cli 0.1.0

package/src/shared/logger.ts

@@ -0,0 +1,248 @@
+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

@@ -0,0 +1,73 @@
+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

@@ -0,0 +1,110 @@
+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

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