@chroxify/eunoe 0.1.0 → 1.0.0

package/src/proxy/server.ts

@@ -1,16 +1,20 @@
 import path from "node:path"
-import { claudeConfigDirs, loadConfig } from "../config"
+import { claudeConfigDirs, loadConfig, settingsFor } from "../config"
 import type { Config } from "../config/types"
+import { wellFormed } from "../context/content"
 import type { Body } from "../context/types"
 import { findSessionFile } from "../transcript/locate"
 import { prepareTranscript } from "../transcript/search"
 import { VERSION } from "../version"
-import { HEALTH_PATH, IDLE_TIMEOUT_SECONDS, LOGGED_ERROR_CHARS, OMITTED_BEFORE_HEADER, SESSION_HEADER, TRANSCRIPT_HEADER } from "./constants"
+import { CANONICAL_HEADER, HEALTH_PATH, IDLE_TIMEOUT_SECONDS, LOGGED_ERROR_CHARS, OMITTED_BEFORE_HEADER, SESSION_HEADER, TRANSCRIPT_HEADER, WINDOW_HEADER } from "./constants"
+import { applyCanonical } from "./canonical"
 import { sizeOf } from "./estimate"
+import { contextFingerprint } from "./fingerprint"
 import { logRequest } from "./log"
-import { rewrite } from "./rewrite"
+import { rewriteAsync } from "./rewrite"
+import { recordSession } from "./sessions"
 import { loadState, saveState } from "./state"
-import type { Health, Note } from "./types"
+import type { ContextFingerprint, Health, Note } from "./types"
 import { inputTokens, watchUsage } from "./usage"
 import { resolveWindow } from "./window"
 
@@ -31,17 +35,21 @@ function forwardableHeaders(headers: Headers) {
   return out
 }
 
-async function prepare(request: Request, body: Body, config: Config, isCountTokens: boolean) {
+async function prepare(request: Request, body: Body, base: Config, isCountTokens: boolean) {
   const sessionId = sessionIdOf(request.headers, body)
+  const config = settingsFor(base, sessionId)
   const trusted = config.eval?.trustHeaders === true
   const transcriptOverride = trusted ? request.headers.get(TRANSCRIPT_HEADER) : null
   const sessionFile = transcriptOverride ?? (sessionId ? findSessionFile(sessionId, claudeConfigDirs(config)) : null)
+  if (sessionId && !trusted) recordSession(sessionId, config.mode, sessionFile)
+  if (config.mode === "off") return rewriteAsync({ body, sessionId, config, transcript: null, window: null, mayCompact: false })
   const transcript = sessionFile && sessionId
     ? prepareTranscript(config.search, sessionFile, transcriptOverride ? path.basename(transcriptOverride, ".jsonl") : sessionId)
     : null
-  const needsWindow = config.mode === "compact" || config.eval?.strategy === "tail"
-  const window = config.window ?? (needsWindow ? await resolveWindow(body.model, request.headers, config.upstream) : null)
-  return rewrite({
+  const needsWindow = !config.eval?.strategy || config.eval.strategy === "tail"
+  const windowOverride = trusted ? Number(request.headers.get(WINDOW_HEADER)) || null : null
+  const window = windowOverride ?? config.window ?? (needsWindow ? await resolveWindow(body.model, request.headers, config.upstream) : null)
+  return rewriteAsync({
     body,
     sessionId,
     config,
@@ -67,15 +75,22 @@ export async function handle(request: Request): Promise<Response> {
   let note: Note = { action: "pass" }
   let threadKey: string | null = null
   let sentSize = 0
+  let givenSize = 0
+  let sent: (ContextFingerprint & { session: string | null }) | null = null
 
   if (bodyText && isMessages) {
     try {
-      const body = JSON.parse(bodyText) as Body
+      const given = JSON.parse(bodyText) as Body
+      const canonicalFile = config.eval?.trustHeaders ? request.headers.get(CANONICAL_HEADER) : null
+      const canonical = canonicalFile ? applyCanonical(given, canonicalFile) : null
+      const body = canonical?.body ?? given
       const result = await prepare(request, body, config, isCountTokens)
-      note = result.note
+      note = canonical ? { ...result.note, canonical: canonical.status } : result.note
       threadKey = result.threadKey
-      if (result.body !== body) bodyText = JSON.stringify(result.body)
+      if (result.body !== given) bodyText = JSON.stringify(result.body, wellFormed)
       sentSize = sizeOf(result.body)
+      givenSize = result.body === given ? sentSize : sizeOf(given)
+      if (config.eval) sent = { session: sessionIdOf(request.headers, given), ...contextFingerprint(result.body), given: contextFingerprint(given) }
     } catch (error) {
       note = { action: "error-passthrough", error: String(error) }
     }
@@ -91,7 +106,7 @@ export async function handle(request: Request): Promise<Response> {
 
   const response = new Response(upstream.body, { status: upstream.status, statusText: upstream.statusText, headers: forwardableHeaders(upstream.headers) })
   if (note.action === "pass" || !isMessages || isCountTokens) {
-    if (note.action !== "pass") logRequest({ path: url.pathname, status: upstream.status, ...note })
+    if (note.action !== "pass" || sent) logRequest({ path: url.pathname, status: upstream.status, ...note, ...(sent && { context: sent }) })
     return response
   }
 
@@ -106,6 +121,9 @@ export async function handle(request: Request): Promise<Response> {
       cacheRead: usage.cache_read_input_tokens ?? 0,
       cacheWrite: usage.cache_creation_input_tokens ?? 0,
       uncached: usage.input_tokens ?? 0,
+      charsIn: givenSize,
+      charsOut: sentSize,
+      ...(sent && { context: sent }),
     })
     if (threadKey && input > 0 && sentSize > 0) {
       const state = loadState(threadKey)

package/src/proxy/sessions.ts

@@ -0,0 +1,46 @@
+import { closeSync, mkdirSync, openSync, readFileSync, readSync, writeFileSync } from "node:fs"
+import { EUNOE_DIR, paths } from "../config/constants"
+import type { Mode } from "../config/types"
+import { SESSION_HEAD_BYTES, SESSION_SEEN_INTERVAL_MS, SESSIONS_KEPT } from "./constants"
+import type { SeenSession } from "./types"
+
+let seen: Record<string, SeenSession> | null = null
+
+function load(): Record<string, SeenSession> {
+  try {
+    return JSON.parse(readFileSync(paths.sessions, "utf8"))
+  } catch {
+    return {}
+  }
+}
+
+function cwdOf(sessionFile: string): string | undefined {
+  try {
+    const fd = openSync(sessionFile, "r")
+    const buffer = Buffer.alloc(SESSION_HEAD_BYTES)
+    const read = readSync(fd, buffer, 0, SESSION_HEAD_BYTES, 0)
+    closeSync(fd)
+    return buffer.subarray(0, read).toString("utf8").match(/"cwd":"((?:[^"\\]|\\.)*)"/)?.[1]
+  } catch {
+    return undefined
+  }
+}
+
+export function recordSession(sessionId: string, mode: Mode, sessionFile: string | null) {
+  seen ??= load()
+  const previous = seen[sessionId]
+  const now = Date.now()
+  const needsCwd = !previous?.cwd && sessionFile !== null
+  if (previous && previous.mode === mode && !needsCwd && now - Date.parse(previous.lastSeen) < SESSION_SEEN_INTERVAL_MS) return
+  seen[sessionId] = { lastSeen: new Date(now).toISOString(), mode, cwd: previous?.cwd ?? (sessionFile ? cwdOf(sessionFile) : undefined) }
+  const kept = Object.entries(seen).sort(([, a], [, b]) => b.lastSeen.localeCompare(a.lastSeen)).slice(0, SESSIONS_KEPT)
+  seen = Object.fromEntries(kept)
+  try {
+    mkdirSync(EUNOE_DIR, { recursive: true })
+    writeFileSync(paths.sessions, JSON.stringify(seen, null, 2))
+  } catch {}
+}
+
+export function seenSessions(): Array<[string, SeenSession]> {
+  return Object.entries(load()).sort(([, a], [, b]) => b.lastSeen.localeCompare(a.lastSeen))
+}

package/src/proxy/types.ts

@@ -7,10 +7,28 @@ export interface ThreadState {
   keep?: number
   cleared?: number
   ratio?: number
+  recalls?: Record<string, string>
 }
 
 export type Note = Record<string, unknown>
 
+export interface ContextFingerprint {
+  system: string
+  tools: string
+  skills: string[]
+  given?: ContextFingerprint
+}
+
+export interface Canonical {
+  system: Body["system"]
+  tools: Body["tools"]
+}
+
+export interface CanonicalResult {
+  body: Body
+  status: "applied" | "captured" | "skipped"
+}
+
 export interface RewriteInput {
   body: Body
   sessionId: string | null
@@ -50,6 +68,12 @@ export interface Estimator {
 
 export type Usage = Record<string, number>
 
+export interface SeenSession {
+  lastSeen: string
+  mode: Config["mode"]
+  cwd?: string
+}
+
 export interface Health {
   ok: boolean
   version: string

package/src/transcript/constants.ts

@@ -13,4 +13,3 @@ export const TURN_COUNT_FILE = ".turns"
 export const INDEX_FILE = "index.md"
 export const QMD_DIR = ".qmd"
 
-export const SESSION_ID_PATTERN = /^[a-zA-Z0-9-]+$/

package/src/transcript/locate.ts

@@ -1,6 +1,6 @@
 import { existsSync, readdirSync } from "node:fs"
 import path from "node:path"
-import { SESSION_ID_PATTERN } from "./constants"
+import { SESSION_ID_PATTERN } from "../config/constants"
 
 const found = new Map<string, string>()
 

package/src/transcript/messages.ts

@@ -0,0 +1,29 @@
+import { readFileSync, statSync } from "node:fs"
+import type { Message } from "../context/types"
+import type { SessionEntry } from "./types"
+
+let cached: { file: string; mtimeMs: number; messages: Message[] } | null = null
+
+export function sessionMessages(file: string): Message[] {
+  let mtimeMs: number
+  try {
+    mtimeMs = statSync(file).mtimeMs
+  } catch {
+    return []
+  }
+  if (cached?.file === file && cached.mtimeMs === mtimeMs) return cached.messages
+  const messages: Message[] = []
+  for (const line of readFileSync(file, "utf8").split("\n")) {
+    if (!line) continue
+    let entry: SessionEntry
+    try {
+      entry = JSON.parse(line)
+    } catch {
+      continue
+    }
+    if (entry.isSidechain || entry.isCompactSummary || (entry.type !== "user" && entry.type !== "assistant") || !entry.message) continue
+    messages.push({ role: entry.message.role, content: entry.message.content })
+  }
+  cached = { file, mtimeMs, messages }
+  return messages
+}

package/src/cli/commands/install.ts

@@ -1,44 +0,0 @@
-import { existsSync } from "node:fs"
-import path from "node:path"
-import { claudeConfigDirs, loadConfig, saveConfig } from "../../config"
-import { paths } from "../../config/constants"
-import { flagValues } from "../args"
-import { editSettings, proxyUrl, withEunoe } from "../claude-settings"
-import { MODE_DESCRIPTIONS } from "../constants"
-import { routedDirs } from "../inspect"
-import * as launchd from "../launchd"
-import type { Command } from "../types"
-import { c, fail, line, listFiles, note, ok, rows, tilde, warn } from "../ui"
-
-export const install: Command = {
-  summary: "Route Claude Code through eunoe and keep it running",
-  usage: "eunoe install [--config-dir <dir>]",
-  details: [
-    "Starts the proxy in the background and points Claude Code at it by setting",
-    "ANTHROPIC_BASE_URL in settings.json. New sessions pick it up; restart running ones.",
-  ],
-  options: [["--config-dir <dir>", "Also manage this Claude config directory (repeatable, remembered)"]],
-  run(args) {
-    const added = flagValues(args, "--config-dir").map((dir) => path.resolve(dir))
-    for (const dir of added) if (!existsSync(dir)) fail(`No such directory: ${tilde(dir)}`)
-    if (added.length) saveConfig({ claudeConfigDirs: [...new Set([...loadConfig().claudeConfigDirs, ...added])] })
-    const config = loadConfig()
-
-    line()
-    if (launchd.supported) {
-      launchd.installAgent([process.execPath, path.join(import.meta.dir, "..", "main.ts"), "serve"], paths.proxyLog)
-      ok(`Proxy running in the background on ${c.cyan(proxyUrl(config.port))}`)
-    } else {
-      warn("No launchd here, so keep the proxy running yourself:")
-      line(`    ${c.cyan("eunoe serve")}`)
-    }
-    const touched = editSettings(claudeConfigDirs(config), (settings) => withEunoe(settings, config.port, config.mode))
-    ok("Claude Code routed through eunoe")
-    listFiles(touched.length ? touched : routedDirs(config).map((dir) => path.join(dir, "settings.json")))
-    line()
-    rows([["Mode", `${c.bold(config.mode)}  ${c.dim(MODE_DESCRIPTIONS[config.mode])}`]])
-    line()
-    note(`New sessions go through eunoe. Restart any that are already running.`)
-    line()
-  },
-}