feat: LRU instance eviction + max concurrent sessions (#43, #40)

Add LRU eviction to InstanceStore — tracks access order and evicts
least-recently-used instances when cache exceeds max_instances (default
32, configurable via TINYCODE_MAX_INSTANCES env var). Evicted instances
are properly disposed (fibers, watchers, LSP connections cleaned up).

Add max concurrent session enforcement — when TINYCODE_MAX_SESSIONS is
set, ensureRunning() checks active session count before starting a new
processor loop. Excess sessions are rejected with BusyError.

Add server config schema fields: max_instances and max_sessions.

Closes #43, closes #40.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: bobbyjohnstx

packages/tinycode/src/config/server.ts

@@ -13,6 +13,12 @@ export const Server = Schema.Struct({
   cors: Schema.optional(Schema.mutable(Schema.Array(Schema.String))).annotate({
     description: "Additional domains to allow for CORS",
   }),
+  max_instances: Schema.optional(PositiveInt).annotate({
+    description: "Maximum cached project instances. Least-recently-used instances are evicted when exceeded. Default: 32.",
+  }),
+  max_sessions: Schema.optional(PositiveInt).annotate({
+    description: "Maximum concurrent active sessions (busy/processing). New session prompts are rejected when exceeded. Default: unlimited.",
+  }),
 }).annotate({ identifier: "ServerConfig" })
 export type Server = Schema.Schema.Type<typeof Server>
 

packages/tinycode/src/project/instance-store.ts

@@ -31,13 +31,38 @@ interface Entry {
   readonly deferred: Deferred.Deferred<InstanceContext>
 }
 
+const DEFAULT_MAX_INSTANCES = 32
+const MAX_INSTANCES = parseInt(process.env["TINYCODE_MAX_INSTANCES"] ?? "", 10) || DEFAULT_MAX_INSTANCES
+
 export const layer: Layer.Layer<Service, never, Project.Service | InstanceBootstrap.Service> = Layer.effect(
   Service,
   Effect.gen(function* () {
     const project = yield* Project.Service
     const bootstrap = yield* InstanceBootstrap.Service
     const scope = yield* Scope.Scope
     const cache = new Map<string, Entry>()
+    const accessOrder: string[] = []
+    let maxInstances = MAX_INSTANCES
+
+    const touchAccess = (directory: string) => {
+      const idx = accessOrder.indexOf(directory)
+      if (idx !== -1) accessOrder.splice(idx, 1)
+      accessOrder.push(directory)
+    }
+
+    const evictLRU = Effect.fn("InstanceStore.evictLRU")(function* () {
+      while (cache.size > maxInstances && accessOrder.length > 0) {
+        const oldest = accessOrder.shift()!
+        const entry = cache.get(oldest)
+        if (!entry) continue
+        const exit = yield* Deferred.await(entry.deferred).pipe(Effect.exit)
+        if (Exit.isSuccess(exit)) {
+          yield* disposeEntry(oldest, entry, exit.value)
+        } else {
+          yield* removeEntry(oldest, entry)
+        }
+      }
+    })
 
     const boot = (input: LoadInput & { directory: string }) =>
       Effect.gen(function* () {
@@ -63,6 +88,8 @@ export const layer: Layer.Layer<Service, never, Project.Service | InstanceBootst
       Effect.sync(() => {
         if (cache.get(directory) !== entry) return false
         cache.delete(directory)
+        const idx = accessOrder.indexOf(directory)
+        if (idx !== -1) accessOrder.splice(idx, 1)
         return true
       })
 
@@ -107,10 +134,15 @@ export const layer: Layer.Layer<Service, never, Project.Service | InstanceBootst
       return Effect.uninterruptibleMask((restore) =>
         Effect.gen(function* () {
           const existing = cache.get(directory)
-          if (existing) return yield* restore(Deferred.await(existing.deferred))
+          if (existing) {
+            touchAccess(directory)
+            return yield* restore(Deferred.await(existing.deferred))
+          }
 
           const entry: Entry = { deferred: Deferred.makeUnsafe<InstanceContext>() }
           cache.set(directory, entry)
+          touchAccess(directory)
+          yield* evictLRU()
           yield* Effect.gen(function* () {
             yield* Effect.logInfo("creating instance").pipe(Effect.annotateLogs("directory", directory))
             yield* completeLoad(directory, input, entry)

packages/tinycode/src/session/run-state.ts

@@ -7,6 +7,8 @@ import { MessageV2 } from "./message-v2"
 import { SessionID } from "./schema"
 import { SessionStatus } from "./status"
 
+const MAX_SESSIONS = parseInt(process.env["TINYCODE_MAX_SESSIONS"] ?? "", 10) || 0
+
 export interface Interface {
   readonly assertNotBusy: (sessionID: SessionID) => Effect.Effect<void, Session.BusyError>
   readonly cancel: (sessionID: SessionID) => Effect.Effect<void>
@@ -89,6 +91,15 @@ export const layer = Layer.effect(
       onInterrupt: Effect.Effect<MessageV2.WithParts>,
       work: Effect.Effect<MessageV2.WithParts>,
     ) {
+      if (MAX_SESSIONS > 0) {
+        const active = yield* status.list()
+        if (active.size >= MAX_SESSIONS && !active.has(sessionID)) {
+          yield* Effect.logWarning("max concurrent sessions reached").pipe(
+            Effect.annotateLogs({ sessionID, active: active.size, max: MAX_SESSIONS }),
+          )
+          return yield* Effect.die(busyError(sessionID))
+        }
+      }
       return yield* (yield* runner(sessionID, onInterrupt)).ensureRunning(work)
     })