codesearch-mcp 0.1.0-alpha → 0.2.0-alpha

package/dist/src/services/WebServerService.d.ts

@@ -1,13 +1,34 @@
-import type { Config } from '../config';
+import { Config } from '../config';
 import type { ISearcher } from '../interfaces';
 import type { IEmbedder } from '../interfaces';
 import type { ILogger } from '../interfaces';
 import { type JsonConfig } from '../config-store';
+import { type ProvisioningDeps } from './infinity-provisioning';
+export type BackendActionKind = 'started' | 'already-running' | 'not-needed' | 'manual-required' | 'failed';
+export interface BackendActionResult {
+    action: BackendActionKind;
+    message: string | null;
+}
+export type BackendStatusState = 'idle' | 'recreating' | 'ready' | 'failed';
+export interface BackendStatus {
+    state: BackendStatusState;
+    message: string | null;
+    startedAt: string | null;
+    finishedAt: string | null;
+}
+export interface WebServerDeps {
+    /** Path to the managed docker-compose.yml. Defaults to `CONFIG_DIR/docker-compose.yml`. */
+    composePath?: string;
+    /** Injection seams (fetchImpl/runCommand/pollIntervalMs/readinessTimeoutMs) for the readiness primitive. */
+    provisioning?: ProvisioningDeps;
+    /** Reads the just-saved config back — defaults to `() => new Config()`. Injectable for tests. */
+    readSavedConfig?: () => Config;
+}
 /**
  * Per-field choice lists for the config form. `strict` → render a dropdown that
  * only accepts a listed value (e.g. the embedding model, tied to the vector
  * dimension). Non-strict → a combobox: the values are suggestions but free text
- * is still allowed (e.g. any Ollama model the user has pulled).
+ * is still allowed (e.g. any model served by a self-hosted backend).
  */
 export interface FieldOption {
     values: string[];
@@ -41,7 +62,13 @@ export declare class WebServer {
     private readonly logger;
     private readonly embedder;
     private server?;
-    constructor(searcher: ISearcher, config: Config, logger: ILogger, embedder: IEmbedder);
+    private readonly composePath;
+    private readonly provisioningDeps;
+    private readonly readSavedConfig;
+    private backendStatus;
+    private taskInFlight;
+    private pending;
+    constructor(searcher: ISearcher, config: Config, logger: ILogger, embedder: IEmbedder, deps?: WebServerDeps);
     start(port: number, host: string): Promise<void>;
     stop(): Promise<void>;
     /** The bound address once started (e.g. `.port` after listen(0)); null otherwise. */
@@ -51,6 +78,17 @@ export declare class WebServer {
     private handle;
     private maskedConfig;
     private saveConfig;
+    /**
+     * After a successful config write, decide the Infinity backend action per
+     * the first-match decision table (`local-backend-provisioning`). Computes
+     * the required set from the SAVED config (a fresh `Config` re-read from the
+     * file just written — never the server's startup config/embedder). Never
+     * throws — an unexpected error becomes `{ action: 'failed', message }`; the
+     * saved config and `GET /api/backend-status` are unaffected either way.
+     */
+    private evaluateBackendAfterSave;
+    /** Kick off (or continue, via a follow-up) a background Infinity recreate. */
+    private startBackgroundTask;
     /**
      * Choice lists for model fields. Both are non-strict comboboxes (free text
      * allowed): the embedding model suggests the known registry models plus any

package/dist/src/services/WebServerService.js

@@ -38,10 +38,15 @@ exports.mergeConfigForSave = mergeConfigForSave;
 exports.maskConfig = maskConfig;
 const http = __importStar(require("http"));
 const path = __importStar(require("path"));
+const config_1 = require("../config");
 const config_store_1 = require("../config-store");
 const constants_1 = require("../constants");
 const graph_1 = require("../graph");
 const dashboard_1 = require("../web/dashboard");
+const infinity_provisioning_1 = require("./infinity-provisioning");
+function sameModelSet(a, b) {
+    return a.join(';') === b.join(';');
+}
 /** Placeholder shown to the browser instead of a real secret. */
 exports.PASSWORD_MASK = '********';
 const MAX_BODY = 1_000_000; // 1 MB — config payloads are tiny
@@ -100,11 +105,22 @@ class WebServer {
     logger;
     embedder;
     server;
-    constructor(searcher, config, logger, embedder) {
+    composePath;
+    provisioningDeps;
+    readSavedConfig;
+    // Background Infinity-recreate task state (D6). In-memory, per-process — see
+    // `GET /api/backend-status`. `pending` holds at most one queued follow-up.
+    backendStatus = { state: 'idle', message: null, startedAt: null, finishedAt: null };
+    taskInFlight = false;
+    pending = null;
+    constructor(searcher, config, logger, embedder, deps = {}) {
         this.searcher = searcher;
         this.config = config;
         this.logger = logger;
         this.embedder = embedder;
+        this.composePath = deps.composePath ?? path.join(config_store_1.CONFIG_DIR, 'docker-compose.yml');
+        this.provisioningDeps = deps.provisioning ?? {};
+        this.readSavedConfig = deps.readSavedConfig ?? (() => new config_1.Config());
     }
     async start(port, host) {
         this.server = http.createServer((req, res) => {
@@ -149,6 +165,8 @@ class WebServer {
             return this.json(res, 200, this.maskedConfig());
         if (m === 'PUT' && p === '/api/config')
             return this.saveConfig(req, res);
+        if (m === 'GET' && p === '/api/backend-status')
+            return this.json(res, 200, this.backendStatus);
         if (m === 'GET' && p === '/api/projects')
             return this.json(res, 200, await this.searcher.listProjects());
         if (m === 'GET' && p === '/api/graph')
@@ -186,7 +204,77 @@ class WebServer {
         }
         (0, config_store_1.writeConfigJson)(validated);
         this.logger.info('WebServer: config updated');
-        this.json(res, 200, { ok: true });
+        const backend = await this.evaluateBackendAfterSave(validated);
+        this.json(res, 200, { ok: true, backend });
+    }
+    /**
+     * After a successful config write, decide the Infinity backend action per
+     * the first-match decision table (`local-backend-provisioning`). Computes
+     * the required set from the SAVED config (a fresh `Config` re-read from the
+     * file just written — never the server's startup config/embedder). Never
+     * throws — an unexpected error becomes `{ action: 'failed', message }`; the
+     * saved config and `GET /api/backend-status` are unaffected either way.
+     */
+    async evaluateBackendAfterSave(saved) {
+        const provider = saved.embedding?.provider ?? config_store_1.CONFIG_DEFAULTS['embedding.provider'];
+        if (provider !== 'infinity') {
+            this.pending = null;
+            return { action: 'not-needed', message: null };
+        }
+        try {
+            const freshConfig = this.readSavedConfig();
+            const baseURL = freshConfig.embedding.baseURL;
+            const composePath = this.composePath;
+            const modelSet = (0, infinity_provisioning_1.requiredModelSet)(freshConfig);
+            const managed = (0, infinity_provisioning_1.isManagedInfinity)(baseURL, composePath);
+            if (this.taskInFlight) {
+                if (managed) {
+                    this.pending = { modelSet, baseURL, composePath };
+                    return { action: 'already-running', message: 'A backend recreate is already in progress; this configuration will be applied next.' };
+                }
+                // No longer targets the managed container the in-flight task owns.
+                this.pending = null;
+            }
+            const evaluation = await (0, infinity_provisioning_1.evaluateBackend)(baseURL, composePath, modelSet, this.provisioningDeps);
+            switch (evaluation.action) {
+                case 'served':
+                    return { action: 'not-needed', message: null };
+                case 'missing-external':
+                case 'unreachable-external':
+                    return { action: 'manual-required', message: (0, infinity_provisioning_1.manualInstructionMessage)(evaluation, (0, infinity_provisioning_1.serverRoot)(baseURL), modelSet) };
+                case 'missing-managed':
+                case 'unreachable-managed':
+                    this.startBackgroundTask(baseURL, composePath, modelSet);
+                    return { action: 'started', message: 'Recreating the managed Infinity container in the background.' };
+            }
+        }
+        catch (err) {
+            return { action: 'failed', message: err instanceof Error ? err.message : String(err) };
+        }
+    }
+    /** Kick off (or continue, via a follow-up) a background Infinity recreate. */
+    startBackgroundTask(baseURL, composePath, modelSet) {
+        this.taskInFlight = true;
+        this.backendStatus = { state: 'recreating', message: null, startedAt: new Date().toISOString(), finishedAt: null };
+        (0, infinity_provisioning_1.ensureModelSetServed)(baseURL, composePath, modelSet, this.provisioningDeps)
+            .then(() => {
+            this.backendStatus = { ...this.backendStatus, state: 'ready', message: null, finishedAt: new Date().toISOString() };
+        })
+            .catch((err) => {
+            this.backendStatus = {
+                ...this.backendStatus, state: 'failed',
+                message: err instanceof Error ? err.message : String(err),
+                finishedAt: new Date().toISOString(),
+            };
+        })
+            .finally(() => {
+            this.taskInFlight = false;
+            const next = this.pending;
+            this.pending = null;
+            if (next && !sameModelSet(next.modelSet, modelSet)) {
+                this.startBackgroundTask(next.baseURL, next.composePath, next.modelSet);
+            }
+        });
     }
     /**
      * Choice lists for model fields. Both are non-strict comboboxes (free text

package/dist/src/services/infinity-provisioning.d.ts

@@ -0,0 +1,115 @@
+import type { Config } from '../config';
+/** Result of a shell command run, mirroring the parts of `spawnSync` we use. */
+export interface CommandResult {
+    status: number | null;
+    stdout?: string;
+    stderr?: string;
+}
+/** Injection seams for the provisioning primitive. All optional, defaulted to the real implementations. */
+export interface ProvisioningDeps {
+    fetchImpl?: typeof fetch;
+    /** Runs a shell command (docker). Defaults to `spawnSync` with captured output. */
+    runCommand?: (cmd: string, args: string[]) => CommandResult;
+    /** Sleep between readiness polls (ms), capped at 5000. Defaults to 2000; tests pass 0. */
+    pollIntervalMs?: number;
+    /** Readiness wait timeout (ms). Defaults to 1,800,000 (30 min); tests override to run fast. */
+    readinessTimeoutMs?: number;
+}
+/**
+ * Strip trailing slashes and a trailing `/embeddings` or `/v1` to get the server
+ * root — Infinity serves `/health`, `/models`, `/rerank`, `/embeddings` from the
+ * root, so a baseURL written with an OpenAI-style suffix must be normalized here
+ * to keep the probe/models URLs aligned with the embeddings URL.
+ */
+export declare function serverRoot(baseURL: string): string;
+/**
+ * Probe an Infinity-style `/health` endpoint. Resolves `true` when the server
+ * answers with a 2xx, `false` on any error, non-2xx, or timeout.
+ */
+export declare function probeInfinityHealth(baseURL: string, fetchImpl?: typeof fetch, timeoutMs?: number): Promise<boolean>;
+/**
+ * List the model ids an Infinity server currently serves via its OpenAI-style
+ * `/models` listing (`{ data: [{ id }] }`). Returns `[]` on any error, non-2xx,
+ * or timeout — callers treat an empty/unverifiable listing as "served".
+ */
+export declare function listInfinityModels(baseURL: string, fetchImpl?: typeof fetch, timeoutMs?: number): Promise<string[]>;
+/**
+ * Two URLs target the same server when scheme, (loopback-normalised) host, and
+ * port (explicit or scheme default) all match; path is ignored. An unparsable
+ * URL is never the same server as another.
+ */
+export declare function sameServer(a: string, b: string): boolean;
+/**
+ * "Managed" per the managed-vs-external requirement: the compose file exists,
+ * declares an `infinity` service, the base URL host is loopback, and its port
+ * (explicit or scheme default) equals the service's published host port.
+ * Never throws — an unreadable/unparsable file or an unrecognised port form
+ * is simply "external".
+ */
+export declare function isManagedInfinity(baseURL: string, composePath: string): boolean;
+/** The literal (non-`${…}`) `INFINITY_MODEL_ID` value in the compose file's `infinity` service, or null. */
+export declare function extractModelIdValue(composeContent: string): string | null;
+/** Write `content` to `targetPath` via a same-directory temp file + rename; removes the temp file on failure. */
+export declare function atomicWriteFile(targetPath: string, content: string, mode: number): void;
+/**
+ * Write `modelSet` (embedding model first) as the literal `INFINITY_MODEL_ID`
+ * of the compose file's `infinity` service, and remove a `profiles:` entry of
+ * that service if present (a file written by an earlier version). At most
+ * those two targeted edits — every other byte unchanged. Atomic (temp file +
+ * rename), keeps the original file's mode. Throws (no write, original file
+ * unchanged) when the file cannot be read, has no `infinity` service, has no
+ * `INFINITY_MODEL_ID:` line, or the write itself fails.
+ */
+export declare function writeComposeModelSet(composePath: string, modelSet: string[]): void;
+/** True when an NVIDIA GPU + `nvidia-smi` is available on this host. */
+export declare function hasNvidiaGpu(): boolean;
+/** The `-f` file args a docker compose invocation against `composePath` should use (base, plus GPU override when present + detected). */
+export declare function composeFileArgs(composePath: string): string[];
+export type BackendAction = 'served' | 'missing-managed' | 'missing-external' | 'unreachable-managed' | 'unreachable-external';
+export interface BackendEvaluation {
+    action: BackendAction;
+    managed: boolean;
+    /** Required models absent from the served listing; empty for `served` or an unverifiable listing. */
+    missingModels: string[];
+    /** The full served listing at evaluation time; empty for an unverifiable listing or when unreachable. */
+    servedModels: string[];
+}
+/**
+ * Classify the backend against `requiredModels` without touching Docker:
+ * reachable+served (or unverifiable listing) → `served`; reachable+missing →
+ * `missing-managed`/`missing-external`; unreachable → `unreachable-managed`/
+ * `unreachable-external`. Shared by `ensureBackendReady`, the web-dashboard
+ * decision table, and `rag-setup`'s declined-Docker branch.
+ */
+export declare function evaluateBackend(baseURL: string, composePath: string, requiredModels: string[], deps?: ProvisioningDeps): Promise<BackendEvaluation>;
+/** Human-readable manual instructions for a `missing-external`/`unreachable-external` evaluation. */
+export declare function manualInstructionMessage(evaluation: BackendEvaluation, base: string, modelSetToWrite: string[]): string;
+export interface EnsureBackendReadyOpts {
+    baseURL: string;
+    /** Models that must be served for the call to succeed without a recreate/instructions. */
+    requiredModels: string[];
+    /** Full model set to write into the compose file and bind at startup when a start/recreate is needed. */
+    modelSetToWrite: string[];
+    composePath: string;
+    deps?: ProvisioningDeps;
+}
+/**
+ * Bring the Infinity backend to a state serving `requiredModels`, per the
+ * managed-vs-external decision tree:
+ *   served                → return (no Docker)
+ *   missing-managed       → recreate (writes modelSetToWrite) + wait
+ *   missing-external      → throw (manual --model-id instructions)
+ *   unreachable-managed   → (re)create + wait
+ *   unreachable-external  → throw (manual launch instructions)
+ */
+export declare function ensureBackendReady(opts: EnsureBackendReadyOpts): Promise<void>;
+/** `ensureBackendReady` with the full set as both the requirement and the write (rag-setup, web dashboard). */
+export declare function ensureModelSetServed(baseURL: string, composePath: string, modelSet: string[], deps?: ProvisioningDeps): Promise<void>;
+/**
+ * The model set a managed Infinity container must serve, computed from a
+ * `Config`: the embedding model, followed by the reranker model only when
+ * reranking is enabled with a model on the same server as embeddings (the
+ * effective `reranker.url`, which `Config` has already resolved from an
+ * explicit value or derived from `reranker.baseURL`).
+ */
+export declare function requiredModelSet(cfg: Config): string[];