claudeye 0.2.2 → 0.3.0

package/.next/standalone/dist/server-spawn.js

@@ -14,20 +14,34 @@ const node_net_1 = require("node:net");
 const node_path_1 = require("node:path");
 const node_fs_1 = require("node:fs");
 const node_os_1 = require("node:os");
-function findAvailablePort(preferred) {
-    return new Promise((res, rej) => {
+function getNetworkAddress() {
+    for (const addrs of Object.values((0, node_os_1.networkInterfaces)())) {
+        for (const iface of addrs) {
+            if (iface.family === "IPv4" && !iface.internal) {
+                return iface.address;
+            }
+        }
+    }
+    return "0.0.0.0";
+}
+function resolveBindAddress(host) {
+    return host === "localhost" ? "127.0.0.1" : host;
+}
+function findAvailablePort(preferred, host = "localhost") {
+    const bindAddr = resolveBindAddress(host);
+    return new Promise((resolve, reject) => {
         const srv = (0, node_net_1.createServer)();
-        srv.listen(preferred, "127.0.0.1", () => {
-            srv.close(() => res(preferred));
+        srv.listen(preferred, bindAddr, () => {
+            srv.close(() => resolve(preferred));
         });
         srv.on("error", () => {
-            const srv2 = (0, node_net_1.createServer)();
-            srv2.listen(0, "127.0.0.1", () => {
-                const addr = srv2.address();
+            const fallback = (0, node_net_1.createServer)();
+            fallback.listen(0, bindAddr, () => {
+                const addr = fallback.address();
                 const port = typeof addr === "object" && addr ? addr.port : 0;
-                srv2.close(() => res(port));
+                fallback.close(() => resolve(port));
             });
-            srv2.on("error", rej);
+            fallback.on("error", reject);
         });
     });
 }
@@ -81,41 +95,52 @@ function resolveServerInfo() {
     // Fallback to dev mode
     return { mode: "dev" };
 }
-async function spawnServer(preferredPort, options) {
-    const port = await findAvailablePort(preferredPort);
-    if (port !== preferredPort) {
-        console.log(`Port ${preferredPort} is busy, using port ${port} instead.`);
-    }
-    const url = `http://localhost:${port}`;
-    const evalsModule = process.argv[1] ? (0, node_path_1.resolve)(process.argv[1]) : undefined;
+function logServerInfo(host, port, localUrl, evalsModule) {
     console.log(`Starting Claudeye dashboard...`);
     if (evalsModule) {
         console.log(`  Evals:    ${evalsModule}`);
     }
-    console.log(`  URL:      ${url}\n`);
-    const env = Object.assign(Object.assign({}, process.env), { PORT: String(port), HOSTNAME: "localhost" });
-    if (evalsModule) {
-        env.CLAUDEYE_EVALS_MODULE = evalsModule;
+    if (host === "0.0.0.0") {
+        console.log(`  Local:    ${localUrl}`);
+        console.log(`  Network:  http://${getNetworkAddress()}:${port}`);
     }
-    const serverInfo = resolveServerInfo();
-    let child;
+    else {
+        console.log(`  URL:      http://${host}:${port}`);
+    }
+    console.log();
+}
+function spawnChildProcess(serverInfo, env, port) {
     if (serverInfo.mode === "standalone") {
-        child = (0, node_child_process_1.spawn)(process.execPath, [serverInfo.script], {
+        return (0, node_child_process_1.spawn)(process.execPath, [serverInfo.script], {
             cwd: serverInfo.cwd,
             stdio: "inherit",
             env,
         });
     }
-    else {
-        child = (0, node_child_process_1.spawn)("npx", ["next", "dev", "--port", String(port)], {
-            stdio: "inherit",
-            shell: true,
-            env,
-        });
+    return (0, node_child_process_1.spawn)("npx", ["next", "dev", "--port", String(port)], {
+        stdio: "inherit",
+        shell: true,
+        env,
+    });
+}
+async function spawnServer(preferredPort, options) {
+    var _a;
+    const host = (_a = options.host) !== null && _a !== void 0 ? _a : "localhost";
+    const port = await findAvailablePort(preferredPort, host);
+    if (port !== preferredPort) {
+        console.log(`Port ${preferredPort} is busy, using port ${port} instead.`);
+    }
+    const localUrl = `http://localhost:${port}`;
+    const evalsModule = process.argv[1] ? (0, node_path_1.resolve)(process.argv[1]) : undefined;
+    logServerInfo(host, port, localUrl, evalsModule);
+    const env = Object.assign(Object.assign({}, process.env), { PORT: String(port), HOSTNAME: host });
+    if (evalsModule) {
+        env.CLAUDEYE_EVALS_MODULE = evalsModule;
     }
+    const child = spawnChildProcess(resolveServerInfo(), env, port);
     if (options.open) {
-        waitForServer(url).then(() => openBrowser(url)).catch(() => {
-            console.warn(`\nServer did not respond within 15 s.\nOpen manually: ${url}\n`);
+        waitForServer(localUrl).then(() => openBrowser(localUrl)).catch(() => {
+            console.warn(`\nServer did not respond within 15 s.\nOpen manually: ${localUrl}\n`);
         });
     }
     // Forward signals for clean shutdown
@@ -125,12 +150,11 @@ async function spawnServer(preferredPort, options) {
     };
     process.on("SIGINT", () => shutdown("SIGINT"));
     process.on("SIGTERM", () => shutdown("SIGTERM"));
-    return new Promise((res) => {
+    // Block until the child exits — server runs until killed
+    await new Promise(() => {
         child.on("exit", (code) => {
             process.exit(code !== null && code !== void 0 ? code : 0);
         });
-        // Never resolves — server runs until killed
-        void res;
     });
 }
 //# sourceMappingURL=server-spawn.js.map

package/.next/standalone/lib/cache/hash.ts

@@ -0,0 +1,67 @@
+import { createHash } from "crypto";
+import { stat, readFile } from "fs/promises";
+import { join } from "path";
+import { getClaudeProjectsPath } from "../paths";
+
+/**
+ * Hashes a session file using its mtime + size for speed.
+ * JSONL session files are append-only, so mtime+size reliably
+ * detects changes without reading the full file.
+ */
+export async function hashSessionFile(
+  projectName: string,
+  sessionId: string,
+): Promise<string> {
+  const projectsPath = getClaudeProjectsPath();
+  const filePath = join(projectsPath, projectName, `${sessionId}.jsonl`);
+  const s = await stat(filePath);
+  const content = `${s.mtimeMs}:${s.size}`;
+  return createHash("sha256").update(content).digest("hex");
+}
+
+/**
+ * Hashes a subagent log file using its mtime + size for speed.
+ * Tries multiple candidate paths (same logic as load-subagent-log)
+ * and hashes the first one found. Returns empty string if none found.
+ */
+export async function hashSubagentFile(
+  projectName: string,
+  sessionId: string,
+  agentId: string,
+): Promise<string> {
+  const projectsPath = getClaudeProjectsPath();
+  const fileName = `agent-${agentId}.jsonl`;
+  const candidatePaths = [
+    join(projectsPath, projectName, fileName),
+    join(projectsPath, projectName, sessionId, fileName),
+    join(projectsPath, projectName, sessionId, "subagents", fileName),
+  ];
+
+  for (const filePath of candidatePaths) {
+    try {
+      const s = await stat(filePath);
+      const content = `${s.mtimeMs}:${s.size}`;
+      return createHash("sha256").update(content).digest("hex");
+    } catch {
+      // Try next candidate
+    }
+  }
+
+  return "";
+}
+
+/**
+ * Hashes the evals module file content. These files are small,
+ * so a full content hash is fine.
+ * Returns empty string if no evals module is configured.
+ */
+export async function hashEvalsModule(): Promise<string> {
+  const evalsModule = process.env.CLAUDEYE_EVALS_MODULE;
+  if (!evalsModule) return "";
+  try {
+    const content = await readFile(evalsModule, "utf-8");
+    return createHash("sha256").update(content).digest("hex");
+  } catch {
+    return "";
+  }
+}

package/.next/standalone/lib/cache/index.ts

@@ -0,0 +1,9 @@
+export type { CacheBackend, CacheMeta, CacheEntry } from "./types";
+export { hashSessionFile, hashSubagentFile, hashEvalsModule } from "./hash";
+export { LocalCacheBackend } from "./local-backend";
+export {
+  initCacheBackend,
+  getCachedResult,
+  setCachedResult,
+  closeCacheBackend,
+} from "./manager";

package/.next/standalone/lib/cache/local-backend.ts

@@ -0,0 +1,81 @@
+import { readFile, writeFile, unlink, readdir, rm, mkdir } from "fs/promises";
+import { join, dirname } from "path";
+import { homedir } from "os";
+import type { CacheBackend, CacheEntry, CacheMeta } from "./types";
+
+const DEFAULT_CACHE_PATH = join(homedir(), ".claudeye", "cache");
+
+export class LocalCacheBackend implements CacheBackend {
+  private basePath: string;
+
+  constructor(basePath?: string) {
+    this.basePath = basePath || DEFAULT_CACHE_PATH;
+  }
+
+  private keyToPath(key: string): string {
+    return join(this.basePath, `${key}.json`);
+  }
+
+  async get<T>(key: string): Promise<CacheEntry<T> | null> {
+    try {
+      const filePath = this.keyToPath(key);
+      const content = await readFile(filePath, "utf-8");
+      return JSON.parse(content) as CacheEntry<T>;
+    } catch {
+      return null;
+    }
+  }
+
+  async set<T>(key: string, value: T, meta: CacheMeta): Promise<void> {
+    try {
+      const filePath = this.keyToPath(key);
+      await mkdir(dirname(filePath), { recursive: true });
+      const entry: CacheEntry<T> = { value, meta };
+      await writeFile(filePath, JSON.stringify(entry), "utf-8");
+    } catch {
+      // Cache write failures should never break eval execution
+    }
+  }
+
+  async invalidate(key: string): Promise<void> {
+    try {
+      await unlink(this.keyToPath(key));
+    } catch {
+      // Ignore if file doesn't exist
+    }
+  }
+
+  async invalidateByPrefix(prefix: string): Promise<void> {
+    try {
+      // Split prefix into directory part and filename prefix.
+      // "evals/project-a/" → dir segments = ["evals","project-a"], filePrefix = ""
+      // "evals/project-a/s" → dir segments = ["evals","project-a"], filePrefix = "s"
+      const parts = prefix.split("/");
+      const filePrefix = parts.pop() || "";
+      const dir = join(this.basePath, ...parts);
+      const entries = await readdir(dir);
+      for (const name of entries) {
+        if (name.endsWith(".json") && name.startsWith(filePrefix)) {
+          await unlink(join(dir, name));
+        }
+      }
+    } catch {
+      // Ignore errors during invalidation
+    }
+  }
+
+  async close(): Promise<void> {
+    // No-op for file backend
+  }
+
+  /**
+   * Remove the entire cache directory. Used by --cache-clear.
+   */
+  async clearAll(): Promise<void> {
+    try {
+      await rm(this.basePath, { recursive: true, force: true });
+    } catch {
+      // Ignore if directory doesn't exist
+    }
+  }
+}

package/.next/standalone/lib/cache/manager.ts

@@ -0,0 +1,127 @@
+import { LocalCacheBackend } from "./local-backend";
+import { hashSessionFile, hashEvalsModule } from "./hash";
+import type { CacheBackend, CacheEntry } from "./types";
+
+const BACKEND_KEY = "__CLAUDEYE_CACHE_BACKEND__";
+const DISABLED_KEY = "__CLAUDEYE_CACHE_DISABLED__";
+
+interface GlobalWithCache {
+  [BACKEND_KEY]?: CacheBackend;
+  [DISABLED_KEY]?: boolean;
+}
+
+/**
+ * Initialize the cache backend (idempotent).
+ * Reads CLAUDEYE_CACHE and CLAUDEYE_CACHE_PATH env vars.
+ * Stores backend in globalThis to survive Next.js hot reloading.
+ */
+export function initCacheBackend(): CacheBackend | null {
+  const g = globalThis as GlobalWithCache;
+
+  if (g[DISABLED_KEY]) return null;
+
+  if (g[BACKEND_KEY]) return g[BACKEND_KEY];
+
+  const cacheEnv = process.env.CLAUDEYE_CACHE;
+  if (cacheEnv === "off") {
+    g[DISABLED_KEY] = true;
+    return null;
+  }
+
+  const cachePath = process.env.CLAUDEYE_CACHE_PATH || undefined;
+  const backend = new LocalCacheBackend(cachePath);
+  g[BACKEND_KEY] = backend;
+  return backend;
+}
+
+function cacheKey(kind: "evals" | "enrichments", projectName: string, sessionKey: string): string {
+  return `${kind}/${projectName}/${sessionKey}`;
+}
+
+/**
+ * Look up cached result. Returns null on any mismatch or cache miss.
+ * `sessionKey` can be a plain session ID or a composite key like `sessionId/agent-xxx`.
+ * When `overrideContentHash` is provided, it is used instead of computing via `hashSessionFile()`.
+ */
+export async function getCachedResult<T>(
+  kind: "evals" | "enrichments",
+  projectName: string,
+  sessionKey: string,
+  registeredNames: string[],
+  overrideContentHash?: string,
+): Promise<(CacheEntry<T> & { cached: true }) | null> {
+  const backend = initCacheBackend();
+  if (!backend) return null;
+
+  try {
+    const entry = await backend.get<T>(cacheKey(kind, projectName, sessionKey));
+    if (!entry) return null;
+
+    // Validate content hash (session/subagent file changed?)
+    const currentContentHash = overrideContentHash ?? await hashSessionFile(projectName, sessionKey);
+    if (entry.meta.contentHash !== currentContentHash) return null;
+
+    // Validate evals module hash (evals file changed?)
+    const currentEvalsHash = await hashEvalsModule();
+    if (entry.meta.evalsModuleHash !== currentEvalsHash) return null;
+
+    // Validate registered names match
+    const cachedNames = [...entry.meta.registeredNames].sort();
+    const currentNames = [...registeredNames].sort();
+    if (
+      cachedNames.length !== currentNames.length ||
+      cachedNames.some((n, i) => n !== currentNames[i])
+    ) {
+      return null;
+    }
+
+    return { ...entry, cached: true };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Store result in cache. Fire-and-forget — errors are swallowed.
+ * `sessionKey` can be a plain session ID or a composite key like `sessionId/agent-xxx`.
+ * When `overrideContentHash` is provided, it is used instead of computing via `hashSessionFile()`.
+ */
+export async function setCachedResult<T>(
+  kind: "evals" | "enrichments",
+  projectName: string,
+  sessionKey: string,
+  value: T,
+  registeredNames: string[],
+  overrideContentHash?: string,
+): Promise<void> {
+  const backend = initCacheBackend();
+  if (!backend) return;
+
+  try {
+    const [contentHash, evalsModuleHash] = await Promise.all([
+      overrideContentHash ? Promise.resolve(overrideContentHash) : hashSessionFile(projectName, sessionKey),
+      hashEvalsModule(),
+    ]);
+
+    await backend.set(cacheKey(kind, projectName, sessionKey), value, {
+      cachedAt: new Date().toISOString(),
+      contentHash,
+      evalsModuleHash,
+      registeredNames,
+    });
+  } catch {
+    // Cache write failures should never break eval execution
+  }
+}
+
+/**
+ * Close the cache backend for clean shutdown.
+ */
+export async function closeCacheBackend(): Promise<void> {
+  const g = globalThis as GlobalWithCache;
+  const backend = g[BACKEND_KEY];
+  if (backend) {
+    await backend.close();
+    delete g[BACKEND_KEY];
+  }
+}

package/.next/standalone/lib/cache/types.ts

@@ -0,0 +1,19 @@
+export interface CacheBackend {
+  get<T>(key: string): Promise<CacheEntry<T> | null>;
+  set<T>(key: string, value: T, meta: CacheMeta): Promise<void>;
+  invalidate(key: string): Promise<void>;
+  invalidateByPrefix(prefix: string): Promise<void>;
+  close(): Promise<void>;
+}
+
+export interface CacheMeta {
+  cachedAt: string;
+  contentHash: string; // session file mtime+size hash
+  evalsModuleHash: string; // evals file content hash
+  registeredNames: string[]; // eval/enricher names at cache time
+}
+
+export interface CacheEntry<T> {
+  value: T;
+  meta: CacheMeta;
+}

package/.next/standalone/lib/evals/app.ts

@@ -9,7 +9,8 @@
  */
 import { registerEval } from "./registry";
 import { registerEnricher } from "./enrich-registry";
-import type { EvalFunction } from "./types";
+import { setGlobalCondition } from "./condition-registry";
+import type { ConditionFunction, EvalFunction, EvalScope } from "./types";
 import type { EnrichFunction } from "./enrich-types";
 
 const LOADING_KEY = "__CLAUDEYE_LOADING_EVALS__";
@@ -21,28 +22,49 @@ interface GlobalWithLoading {
 export interface ClaudeyeAppOptions {
   /** Port for the dashboard (default: 8020). */
   port?: number;
+  /** Host to bind to (default: "localhost"). Use "0.0.0.0" for LAN access. */
+  host?: string;
   /** Whether to auto-open the browser (default: true). */
   open?: boolean;
 }
 
+export interface EvalOptions {
+  condition?: ConditionFunction;
+  scope?: EvalScope;
+  subagentType?: string;
+}
+
+export interface EnrichOptions {
+  condition?: ConditionFunction;
+  scope?: EvalScope;
+  subagentType?: string;
+}
+
 export interface ClaudeyeApp {
+  /** Register a global condition that gates all evals and enrichments. Chainable. */
+  condition(fn: ConditionFunction): ClaudeyeApp;
   /** Register an eval function. Chainable. */
-  eval(name: string, fn: EvalFunction): ClaudeyeApp;
+  eval(name: string, fn: EvalFunction, options?: EvalOptions): ClaudeyeApp;
   /** Register an enricher function. Chainable. */
-  enrich(name: string, fn: EnrichFunction): ClaudeyeApp;
+  enrich(name: string, fn: EnrichFunction, options?: EnrichOptions): ClaudeyeApp;
   /** Start the Claudeye dashboard server. No-op when loading evals in the Next.js process. */
   listen(port?: number, options?: ClaudeyeAppOptions): Promise<void>;
 }
 
 export function createApp(): ClaudeyeApp {
   const app: ClaudeyeApp = {
-    eval(name: string, fn: EvalFunction): ClaudeyeApp {
-      registerEval(name, fn);
+    condition(fn: ConditionFunction): ClaudeyeApp {
+      setGlobalCondition(fn);
+      return app;
+    },
+
+    eval(name: string, fn: EvalFunction, options?: EvalOptions): ClaudeyeApp {
+      registerEval(name, fn, options?.condition, options?.scope, options?.subagentType);
       return app;
     },
 
-    enrich(name: string, fn: EnrichFunction): ClaudeyeApp {
-      registerEnricher(name, fn);
+    enrich(name: string, fn: EnrichFunction, options?: EnrichOptions): ClaudeyeApp {
+      registerEnricher(name, fn, options?.condition, options?.scope, options?.subagentType);
       return app;
     },
 
@@ -59,6 +81,7 @@ export function createApp(): ClaudeyeApp {
       const { spawnServer } = await import("./server-spawn");
       await spawnServer(port ?? options?.port ?? 8020, {
         open: options?.open ?? true,
+        host: options?.host,
       });
     },
   };

package/.next/standalone/lib/evals/condition-registry.ts

@@ -0,0 +1,26 @@
+/**
+ * Module-level singleton condition registry backed by globalThis.
+ * Stores an optional global condition function that gates all evals and enrichments.
+ */
+import type { ConditionFunction } from "./types";
+
+const REGISTRY_KEY = "__CLAUDEYE_CONDITION_REGISTRY__";
+
+interface GlobalWithCondition {
+  [REGISTRY_KEY]?: ConditionFunction | null;
+}
+
+export function setGlobalCondition(fn: ConditionFunction): void {
+  const g = globalThis as GlobalWithCondition;
+  g[REGISTRY_KEY] = fn;
+}
+
+export function getGlobalCondition(): ConditionFunction | null {
+  const g = globalThis as GlobalWithCondition;
+  return g[REGISTRY_KEY] ?? null;
+}
+
+export function clearGlobalCondition(): void {
+  const g = globalThis as GlobalWithCondition;
+  g[REGISTRY_KEY] = null;
+}

package/.next/standalone/lib/evals/enrich-registry.ts

@@ -3,6 +3,7 @@
  * Using globalThis ensures the registry survives webpack chunk splitting
  * and remains a true singleton across dynamic imports.
  */
+import type { ConditionFunction, EvalScope } from "./types";
 import type { EnrichFunction, RegisteredEnricher } from "./enrich-types";
 
 const REGISTRY_KEY = "__CLAUDEYE_ENRICHER_REGISTRY__";
@@ -19,14 +20,23 @@ function getRegistry(): RegisteredEnricher[] {
   return g[REGISTRY_KEY];
 }
 
-export function registerEnricher(name: string, fn: EnrichFunction): void {
+export function registerEnricher(
+  name: string,
+  fn: EnrichFunction,
+  condition?: ConditionFunction,
+  scope: EvalScope = 'session',
+  subagentType?: string,
+): void {
   const registry = getRegistry();
+  const entry: RegisteredEnricher = { name, fn, scope };
+  if (condition) entry.condition = condition;
+  if (subagentType) entry.subagentType = subagentType;
   // Replace if an enricher with the same name already exists
   const idx = registry.findIndex((e) => e.name === name);
   if (idx >= 0) {
-    registry[idx] = { name, fn };
+    registry[idx] = entry;
   } else {
-    registry.push({ name, fn });
+    registry.push(entry);
   }
 }
 
@@ -34,6 +44,22 @@ export function getRegisteredEnrichers(): RegisteredEnricher[] {
   return getRegistry();
 }
 
+export function getSessionScopedEnrichers(): RegisteredEnricher[] {
+  return getRegistry().filter((e) => e.scope === 'session' || e.scope === 'both');
+}
+
+export function getSubagentScopedEnrichers(subagentType?: string): RegisteredEnricher[] {
+  return getRegistry().filter((e) => {
+    if (e.scope !== 'subagent' && e.scope !== 'both') return false;
+    if (e.subagentType && subagentType && e.subagentType !== subagentType) return false;
+    return true;
+  });
+}
+
+export function hasSubagentEnrichers(): boolean {
+  return getRegistry().some((e) => e.scope === 'subagent' || e.scope === 'both');
+}
+
 export function hasEnrichers(): boolean {
   return getRegistry().length > 0;
 }