codesearch-mcp 0.0.18-alpha → 0.2.0-alpha

package/dist/src/services/http-retry.d.ts

@@ -0,0 +1,19 @@
+import type { ILogger } from '../interfaces/ILogger';
+export declare class HttpError extends Error {
+    status: number;
+    constructor(status: number, message: string);
+}
+export interface RetryOpts {
+    /** Total attempts including the first (default 4). */
+    attempts?: number;
+    /** Base backoff in ms; grows exponentially (default 500). Set 0 in tests. */
+    baseDelayMs?: number;
+    logger?: ILogger;
+    label?: string;
+}
+/**
+ * Run `fn` with bounded exponential backoff on HTTP 429/5xx and network errors.
+ * Re-throws the last error once attempts are exhausted or the error is not
+ * transient.
+ */
+export declare function withRetry<T>(fn: () => Promise<T>, opts?: RetryOpts): Promise<T>;

package/dist/src/services/http-retry.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpError = void 0;
+exports.withRetry = withRetry;
+class HttpError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+        this.name = 'HttpError';
+    }
+}
+exports.HttpError = HttpError;
+function sleep(ms) {
+    return ms > 0 ? new Promise(r => setTimeout(r, ms)) : Promise.resolve();
+}
+/** True for transient failures worth retrying (rate limit / server error / network / timeout). */
+function isRetryable(err) {
+    if (err instanceof HttpError)
+        return err.status === 429 || (err.status >= 500 && err.status <= 599);
+    // A request timeout (AbortSignal.timeout) rejects with a DOMException named
+    // 'TimeoutError' — the most common transient cloud failure, so retry it.
+    if (err != null && typeof err === 'object' && err.name === 'TimeoutError')
+        return true;
+    // Network-level errors (fetch throws) are transient too.
+    return err instanceof TypeError;
+}
+/**
+ * Run `fn` with bounded exponential backoff on HTTP 429/5xx and network errors.
+ * Re-throws the last error once attempts are exhausted or the error is not
+ * transient.
+ */
+async function withRetry(fn, opts = {}) {
+    const attempts = opts.attempts ?? 4;
+    const base = opts.baseDelayMs ?? 500;
+    let lastErr;
+    for (let attempt = 1; attempt <= attempts; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (err) {
+            lastErr = err;
+            if (attempt >= attempts || !isRetryable(err))
+                break;
+            const delay = base * Math.pow(2, attempt - 1);
+            opts.logger?.warn('http-retry: transient failure, retrying', {
+                label: opts.label, attempt, attempts, delayMs: delay,
+                reason: err instanceof Error ? err.message : String(err),
+            });
+            await sleep(delay);
+        }
+    }
+    throw lastErr;
+}

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[];