@gmickel/gno 1.17.0 → 1.18.0

package/src/core/job-manager.ts

@@ -46,6 +46,7 @@ export interface JobRecord {
   result?: SyncResult;
   typedResult?: JobResult;
   error?: string;
+  progress?: { current: number; total: number; currentFile?: string };
   serverInstanceId: string;
 }
 
@@ -148,6 +149,24 @@ export class JobManager {
     return this.#jobs.get(jobId);
   }
 
+  getActiveJob(): JobRecord | null {
+    if (!this.#activeJobId) return null;
+    return this.#jobs.get(this.#activeJobId) ?? null;
+  }
+
+  updateJobProgress(
+    jobId: string,
+    progress: { current: number; total: number; currentFile?: string }
+  ): void {
+    const job = this.#jobs.get(jobId);
+    if (job) job.progress = progress;
+  }
+
+  clear(): void {
+    this.#jobs.clear();
+    this.#activeJobId = null;
+  }
+
   listJobs(limit: number = 10): { active: JobRecord[]; recent: JobRecord[] } {
     this.#cleanupExpiredJobs();
 

package/src/core/mutation-generations.ts

@@ -0,0 +1,33 @@
+/** Shared mutation detection for resident content and vector generations. */
+
+interface SyncMutationCounts {
+  filesAdded?: number;
+  filesUpdated?: number;
+  filesMarkedInactive?: number;
+  totalFilesAdded?: number;
+  totalFilesUpdated?: number;
+  collections?: readonly SyncMutationCounts[];
+}
+
+export function hasContentMutation(result: SyncMutationCounts): boolean {
+  return (
+    (result.filesAdded ?? result.totalFilesAdded ?? 0) > 0 ||
+    (result.filesUpdated ?? result.totalFilesUpdated ?? 0) > 0 ||
+    (result.filesMarkedInactive ?? 0) > 0 ||
+    result.collections?.some(hasContentMutation) === true
+  );
+}
+
+export function recordContentMutation(
+  result: SyncMutationCounts,
+  markMutation: (() => void) | undefined
+): void {
+  if (hasContentMutation(result)) markMutation?.();
+}
+
+export function recordIndexMutation(
+  embedded: number,
+  markMutation: (() => void) | undefined
+): void {
+  if (embedded > 0) markMutation?.();
+}

package/src/llm/cache.ts

@@ -46,6 +46,7 @@ const HF_PATH_PATTERN = /^([^/]+)\/([^/]+)\/(.+\.gguf)$/;
 const GGUF_MAGIC = new Uint8Array([0x47, 0x47, 0x55, 0x46]);
 
 type ModelFileOwner = "cache" | "user";
+type ResolveModelFile = typeof import("node-llama-cpp").resolveModelFile;
 
 type ValidatedCachedPath =
   | { ok: true; path: string }
@@ -268,11 +269,16 @@ const MANIFEST_VERSION = "1.0" as const;
 export class ModelCache {
   readonly dir: string;
   private readonly manifestPath: string;
+  private readonly resolveModelFileFn?: ResolveModelFile;
   private manifest: Manifest | null = null;
 
-  constructor(cacheDir?: string) {
+  constructor(
+    cacheDir?: string,
+    deps?: { resolveModelFile?: ResolveModelFile }
+  ) {
     this.dir = cacheDir ?? getModelsCachePath();
     this.manifestPath = join(this.dir, "manifest.json");
+    this.resolveModelFileFn = deps?.resolveModelFile;
   }
 
   /**
@@ -324,7 +330,8 @@ export class ModelCache {
     uri: string,
     type: ModelType,
     onProgress?: ProgressCallback,
-    force?: boolean
+    force?: boolean,
+    signal?: AbortSignal
   ): Promise<LlmResult<string>> {
     const parsed = parseModelUri(uri);
     if (!parsed.ok) {
@@ -364,7 +371,9 @@ export class ModelCache {
     }
 
     try {
-      const { resolveModelFile } = await import("node-llama-cpp");
+      const resolveModelFile =
+        this.resolveModelFileFn ??
+        (await import("node-llama-cpp")).resolveModelFile;
 
       // Convert to node-llama-cpp format (handles quantization shorthand)
       // node-llama-cpp needs hf: prefix to identify HuggingFace models
@@ -399,6 +408,7 @@ export class ModelCache {
               }
             }
           : undefined,
+        signal,
       });
 
       const validation = await validateGgufFile(resolvedPath, uri, "cache");

package/src/llm/nodeLlamaCpp/adapter.ts

@@ -27,7 +27,11 @@ import {
 } from "../registry";
 import { NodeLlamaCppEmbedding } from "./embedding";
 import { NodeLlamaCppGeneration } from "./generation";
-import { getModelManager, type ModelManager } from "./lifecycle";
+import {
+  getModelManager,
+  type ModelLease,
+  type ModelManager,
+} from "./lifecycle";
 import { NodeLlamaCppRerank } from "./rerank";
 
 // ─────────────────────────────────────────────────────────────────────────────
@@ -218,6 +222,11 @@ export class LlmAdapter {
     return this.manager;
   }
 
+  /** Acquire an idempotent request lease without transferring manager ownership. */
+  acquireModelLease(): ModelLease {
+    return this.manager.acquireLease();
+  }
+
   /**
    * Dispose all resources.
    */

package/src/llm/nodeLlamaCpp/lifecycle.ts

@@ -35,6 +35,21 @@ interface CachedModel {
   loadedAt: number;
 }
 
+export interface ModelLease {
+  release(): void;
+}
+
+export interface ModelLifecycleStats {
+  activeLeases: number;
+  leaseAcquisitions: number;
+  leaseReleases: number;
+  loadedModels: number;
+  loadAttempts: number;
+  loadSuccesses: number;
+  loadFailures: number;
+  inflightLoads: number;
+}
+
 let invalidGpuModeWarned = false;
 let invalidBuildModeWarned = false;
 let gpuFallbackWarned = false;
@@ -134,7 +149,14 @@ export class ModelManager {
     new Map();
   private readonly inflightLoads: Map<string, Promise<LlmResult<LoadedModel>>> =
     new Map();
+  private readonly leaseDrainWaiters = new Set<() => void>();
   private readonly config: ModelConfig;
+  private activeLeases = 0;
+  private leaseAcquisitions = 0;
+  private leaseReleases = 0;
+  private loadAttempts = 0;
+  private loadSuccesses = 0;
+  private loadFailures = 0;
 
   constructor(config: ModelConfig) {
     this.config = config;
@@ -263,6 +285,7 @@ export class ModelManager {
     uri: string,
     type: ModelType
   ): Promise<LlmResult<LoadedModel>> {
+    this.loadAttempts += 1;
     const timeoutMs = this.config.loadTimeout;
     let timeoutId: ReturnType<typeof setTimeout> | null = null;
     let timedOut = false;
@@ -299,6 +322,7 @@ export class ModelManager {
 
       this.models.set(uri, cachedModel);
       this.setDisposalTimer(uri);
+      this.loadSuccesses += 1;
 
       return {
         ok: true,
@@ -310,6 +334,7 @@ export class ModelManager {
         },
       };
     } catch (e) {
+      this.loadFailures += 1;
       // Clear timeout on error
       if (timeoutId) {
         clearTimeout(timeoutId);
@@ -356,6 +381,42 @@ export class ModelManager {
     return model;
   }
 
+  /** Keep warm models alive while one request owns model-backed ports. */
+  acquireLease(): ModelLease {
+    this.activeLeases += 1;
+    this.leaseAcquisitions += 1;
+    for (const timer of this.disposalTimers.values()) clearTimeout(timer);
+    this.disposalTimers.clear();
+
+    let released = false;
+    return {
+      release: () => {
+        if (released) return;
+        released = true;
+        this.activeLeases = Math.max(0, this.activeLeases - 1);
+        this.leaseReleases += 1;
+        if (this.activeLeases === 0) {
+          for (const resolve of this.leaseDrainWaiters) resolve();
+          this.leaseDrainWaiters.clear();
+          for (const uri of this.models.keys()) this.setDisposalTimer(uri);
+        }
+      },
+    };
+  }
+
+  getLifecycleStats(): ModelLifecycleStats {
+    return {
+      activeLeases: this.activeLeases,
+      leaseAcquisitions: this.leaseAcquisitions,
+      leaseReleases: this.leaseReleases,
+      loadedModels: this.models.size,
+      loadAttempts: this.loadAttempts,
+      loadSuccesses: this.loadSuccesses,
+      loadFailures: this.loadFailures,
+      inflightLoads: this.inflightLoads.size,
+    };
+  }
+
   /**
    * Check if a model is loaded.
    */
@@ -367,6 +428,10 @@ export class ModelManager {
    * Dispose a specific model.
    */
   async dispose(uri: string): Promise<void> {
+    if (this.activeLeases > 0) {
+      this.resetDisposalTimer(uri);
+      return;
+    }
     const cached = this.models.get(uri);
     if (!cached) {
       return;
@@ -393,6 +458,11 @@ export class ModelManager {
    * Dispose all loaded models.
    */
   async disposeAll(): Promise<void> {
+    if (this.activeLeases > 0) {
+      await new Promise<void>((resolve) => this.leaseDrainWaiters.add(resolve));
+    }
+    await Promise.allSettled(this.inflightLoads.values());
+
     // Clear all timers
     for (const timer of this.disposalTimers.values()) {
       clearTimeout(timer);
@@ -429,6 +499,7 @@ export class ModelManager {
   // ───────────────────────────────────────────────────────────────────────────
 
   private setDisposalTimer(uri: string): void {
+    if (this.activeLeases > 0) return;
     const timer = setTimeout(() => {
       this.dispose(uri).catch(() => {
         // Ignore disposal errors in timer callback

package/src/mcp/context.ts

@@ -0,0 +1,161 @@
+/** Shared MCP surface and request-scoped runtime context. */
+
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+// node:async_hooks provides async-local request context; Bun has no separate native equivalent.
+import { AsyncLocalStorage } from "node:async_hooks";
+
+import type { Collection, Config } from "../config/types";
+import type { JobManager } from "../core/job-manager";
+import type { ModelLease } from "../llm/nodeLlamaCpp/lifecycle";
+import type { ResidentStatus } from "../serve/status-model";
+import type { SqliteAdapter } from "../store/sqlite/adapter";
+
+import { MCP_SERVER_NAME, VERSION } from "../app/constants";
+import { createStandaloneResidentStatus } from "../serve/resident-status";
+import { registerResources } from "./resources/index";
+import { registerTools } from "./tools/index";
+
+export interface AsyncMutex {
+  acquire(): Promise<() => void>;
+}
+
+export class Mutex implements AsyncMutex {
+  #locked = false;
+  readonly #queue: Array<() => void> = [];
+
+  acquire(): Promise<() => void> {
+    return new Promise((resolve) => {
+      const tryAcquire = (): void => {
+        if (this.#locked) {
+          this.#queue.push(tryAcquire);
+          return;
+        }
+        this.#locked = true;
+        resolve(() => this.#release());
+      };
+      tryAcquire();
+    });
+  }
+
+  #release(): void {
+    this.#locked = false;
+    this.#queue.shift()?.();
+  }
+}
+
+export interface ToolContextSnapshot {
+  config: Config;
+  collections: Collection[];
+}
+
+export interface ToolContext {
+  store: SqliteAdapter;
+  config: Config;
+  collections: Collection[];
+  actualConfigPath: string;
+  indexName: string;
+  toolMutex: AsyncMutex;
+  jobManager: JobManager;
+  serverInstanceId: string;
+  writeLockPath: string;
+  enableWrite: boolean;
+  isShuttingDown: () => boolean;
+  getResidentStatus?: () => ResidentStatus;
+  acquireModelLease?: () => ModelLease;
+  markContentMutation?: () => void;
+  markIndexMutation?: () => void;
+  runWithSnapshot?<T>(operation: () => Promise<T>): Promise<T>;
+}
+
+export interface CreateToolContextOptions {
+  store: SqliteAdapter;
+  getConfig: () => Config;
+  setConfig?: (config: Config) => void;
+  actualConfigPath: string;
+  indexName: string;
+  toolMutex: AsyncMutex;
+  jobManager: JobManager;
+  serverInstanceId: string;
+  writeLockPath: string;
+  enableWrite: boolean;
+  isShuttingDown: () => boolean;
+  getResidentStatus?: () => ResidentStatus;
+  acquireModelLease?: () => ModelLease;
+  markContentMutation?: () => void;
+  markIndexMutation?: () => void;
+}
+
+/**
+ * Create a transport-neutral MCP context.
+ *
+ * Config and collection getters resolve from one snapshot captured at the
+ * request boundary, so a hot reload cannot mix old and new values mid-call.
+ */
+export function createToolContext(
+  options: CreateToolContextOptions
+): ToolContext {
+  const requestSnapshot = new AsyncLocalStorage<ToolContextSnapshot>();
+  const currentSnapshot = (): ToolContextSnapshot =>
+    requestSnapshot.getStore() ??
+    (() => {
+      const config = options.getConfig();
+      return { config, collections: config.collections };
+    })();
+
+  return {
+    store: options.store,
+    get config() {
+      return currentSnapshot().config;
+    },
+    set config(config: Config) {
+      options.setConfig?.(config);
+    },
+    get collections() {
+      return currentSnapshot().collections;
+    },
+    set collections(_collections: Collection[]) {
+      // Collections are derived from config. Existing write handlers assign
+      // both for backwards compatibility; the config setter is authoritative.
+    },
+    actualConfigPath: options.actualConfigPath,
+    indexName: options.indexName,
+    toolMutex: options.toolMutex,
+    jobManager: options.jobManager,
+    serverInstanceId: options.serverInstanceId,
+    writeLockPath: options.writeLockPath,
+    enableWrite: options.enableWrite,
+    isShuttingDown: options.isShuttingDown,
+    getResidentStatus:
+      options.getResidentStatus ??
+      (() => createStandaloneResidentStatus("stdio")),
+    acquireModelLease: options.acquireModelLease,
+    markContentMutation: options.markContentMutation,
+    markIndexMutation: options.markIndexMutation,
+    runWithSnapshot<T>(operation: () => Promise<T>): Promise<T> {
+      const config = options.getConfig();
+      return requestSnapshot.run(
+        { config, collections: config.collections },
+        operation
+      );
+    },
+  };
+}
+
+/** Build the contract-identical MCP tool/resource surface for any transport. */
+export function createMcpServerSurface(
+  context: ToolContext,
+  identity: { name: string; version: string } = {
+    name: MCP_SERVER_NAME,
+    version: VERSION,
+  }
+): McpServer {
+  const server = new McpServer(identity, {
+    capabilities: {
+      tools: { listChanged: false },
+      resources: { subscribe: false, listChanged: false },
+    },
+  });
+  registerTools(server, context);
+  registerResources(server, context);
+  return server;
+}