@gmickel/gno 2.10.1 → 2.12.0

package/src/serve/public/pages/Collections.tsx

@@ -81,6 +81,8 @@ interface CollectionStats {
   documentCount: number;
   chunkCount: number;
   embeddedCount: number;
+  /** Set while the folder is missing or unreadable; documents stay indexed. */
+  rootError?: { code: string; message: string };
   include?: string[];
   models?: Partial<Record<"embed" | "rerank" | "expand" | "gen", string>>;
   effectiveModels?: Record<"embed" | "rerank" | "expand" | "gen", string>;
@@ -277,6 +279,12 @@ function CollectionCard({
             </Tooltip>
           </TooltipProvider>
         )}
+        {collection.rootError && (
+          <p className="flex items-start gap-1.5 text-amber-500 text-xs">
+            <AlertCircleIcon className="mt-0.5 size-3.5 shrink-0" />
+            <span>{collection.rootError.message}</span>
+          </p>
+        )}
       </CardHeader>
 
       <CardContent className="pt-2">

package/src/serve/public/pages/Search.tsx

@@ -174,8 +174,12 @@ export default function Search({ navigate }: PageProps) {
     query.trim().length > 0 && !structuredQueryState.ok
       ? structuredQueryState.error.message
       : null;
+  // Without vectors, Fast is keyword search unless modes or intent need the
+  // hybrid endpoint. With vectors, Fast is always hybrid (no expansion,
+  // rerank or graph), the same path as CLI `--fast`.
   const forceHybridForModes =
     thoroughness === "fast" &&
+    !hybridAvailable &&
     (queryModes.length > 0 ||
       intent.trim().length > 0 ||
       (structuredQueryState.ok &&
@@ -325,6 +329,7 @@ export default function Search({ navigate }: PageProps) {
 
       const useBm25 =
         thoroughness === "fast" &&
+        !hybridAvailable &&
         queryModes.length === 0 &&
         intent.trim().length === 0 &&
         !structuredQueryState.value.usedStructuredQuerySyntax;
@@ -403,6 +408,7 @@ export default function Search({ navigate }: PageProps) {
       activePreset,
       category,
       exclude,
+      hybridAvailable,
       intent,
       query,
       queryModes,
@@ -448,7 +454,9 @@ export default function Search({ navigate }: PageProps) {
 
   const thoroughnessDesc =
     thoroughness === "fast"
-      ? "Keyword search (BM25)"
+      ? hybridAvailable
+        ? "Hybrid, no expansion or reranking"
+        : "Keyword search (no vectors)"
       : thoroughness === "balanced"
         ? resolveDepthPolicy({ presetId: activePreset })
             .balancedExpansionEnabled

package/src/serve/resident-request.ts

@@ -2,6 +2,7 @@ import type { ResidentRuntime } from "./resident-runtime";
 /** Admission and bounded-reader boundary for resident REST reads. */
 
 import { withInferenceScope } from "../llm/inference-scope";
+import { StaleCollectionsError } from "../store/sqlite/adapter";
 import { sessionsErrorResponse } from "./routes/sessions";
 
 /**
@@ -16,6 +17,13 @@ export async function refreshResidentConfig(
     await runtime.refreshConfig?.();
     return null;
   } catch (error) {
+    // Names collections only (no paths), and says how to resolve it.
+    if (error instanceof StaleCollectionsError) {
+      return Response.json(
+        { error: { code: "STALE_COLLECTIONS", message: error.message } },
+        { status: 409 }
+      );
+    }
     return sessionsErrorResponse(error);
   }
 }

package/src/serve/resident-runtime.ts

@@ -61,7 +61,11 @@ import {
   readInstanceConfig,
 } from "../sessions/config-refresh";
 import { remoteSafeSessionsError } from "../sessions/types";
-import { SqliteAdapter } from "../store/sqlite/adapter";
+import {
+  SqliteAdapter,
+  StaleCollectionsError,
+  staleCollectionsMessage,
+} from "../store/sqlite/adapter";
 import {
   createServerContext,
   type CreateServerContextOptions,
@@ -519,10 +523,23 @@ export async function startResidentRuntime(
       return undefined;
     }
   };
+  // Another client may index a collection the served config omits after this
+  // runtime started; requests fail instead of reading it.
+  const assertServedCollections = (): void => {
+    const stale = store.staleIndexedCollections(
+      ctxHolder.config.collections.map(({ name }) => name)
+    );
+    if (stale.length > 0) {
+      throw new StaleCollectionsError(staleCollectionsMessage(stale));
+    }
+  };
   const refreshConfig = (): Promise<void> => {
     configRefresh ??= (async () => {
       const stamp = await configStamp();
-      if (stamp !== undefined && stamp === loadedConfigStamp) return;
+      if (stamp !== undefined && stamp === loadedConfigStamp) {
+        assertServedCollections();
+        return;
+      }
       const file = await readInstanceConfig(
         instance,
         deps.loadConfig ?? loadConfig
@@ -535,6 +552,7 @@ export async function startResidentRuntime(
       };
       if (Bun.deepEquals(next, served)) {
         loadedConfigStamp = stamp;
+        assertServedCollections();
         return;
       }
       await adoptServedConfig(
@@ -816,7 +834,11 @@ export async function startResidentRuntime(
         await refreshConfig();
         lastRefreshError = undefined;
       } catch (error) {
-        const message = remoteSafeSessionsError(error).message;
+        // The stale-collections message names collections, never paths.
+        const message =
+          error instanceof StaleCollectionsError
+            ? error.message
+            : remoteSafeSessionsError(error).message;
         if (message !== lastRefreshError)
           console.warn(`gno ${mode}: config not reloaded: ${message}`);
         lastRefreshError = message;

package/src/serve/routes/api.ts

@@ -5,7 +5,6 @@
  * @module src/serve/routes/api
  */
 
-// node:fs/promises structure ops + realpath have no Bun equivalent
 import { readdir, realpath } from "node:fs/promises";
 // node:path has no Bun equivalent
 import { posix as pathPosix } from "node:path";
@@ -90,6 +89,7 @@ import {
   type RecallInput,
   type RememberInput,
 } from "../../core/memory";
+import { readMetadataSummary } from "../../core/metadata-discovery";
 import {
   hasContentMutation,
   recordContentMutation,
@@ -167,6 +167,8 @@ import {
 import { diagnoseQueryTarget } from "../../pipeline/diagnose";
 import { searchHybrid } from "../../pipeline/hybrid";
 import { validateQueryModes } from "../../pipeline/query-modes";
+// node:fs/promises structure ops + realpath have no Bun equivalent
+import { supersedingUri } from "../../pipeline/result-context";
 import { searchBm25 } from "../../pipeline/search";
 import {
   derivePublishArtifactFilename,
@@ -2146,7 +2148,9 @@ export async function handleDoc(
   const record = projectRecordEvidenceMetadata(doc);
   const relPath = doc.recordSourcePath ?? doc.relPath;
 
+  const successor = await supersedingUri(store, doc.uri);
   const responseData = {
+    ...(successor ? { supersededBy: successor } : {}),
     docid: doc.docid,
     uri: doc.uri,
     title: doc.title,
@@ -2463,6 +2467,30 @@ export async function handleDocAsset(
  * Query params: collection, prefix
  * Returns tag list with document counts.
  */
+export async function handleMetadata(
+  store: Pick<StorePort, "getTypedMetadataDocuments">,
+  url: URL
+): Promise<Response> {
+  const collection = url.searchParams.get("collection") ?? undefined;
+  const valuesParam = url.searchParams.get("values");
+  try {
+    return jsonResponse(
+      await readMetadataSummary(store, {
+        collection,
+        values: valuesParam === null ? undefined : Number(valuesParam),
+      })
+    );
+  } catch (cause) {
+    return cause instanceof RangeError
+      ? errorResponse("VALIDATION", cause.message)
+      : errorResponse(
+          "RUNTIME",
+          cause instanceof Error ? cause.message : String(cause),
+          500
+        );
+  }
+}
+
 export async function handleTags(
   store: SqliteAdapter,
   url: URL

package/src/serve/server.ts

@@ -83,6 +83,7 @@ import {
   handleSetPreset,
   handleStatus,
   handleSync,
+  handleMetadata,
   handleTags,
   handleTrashDoc,
   handleUpdateCollection,
@@ -1331,6 +1332,17 @@ export async function startServer(
             }
           },
         },
+        "/api/metadata": {
+          GET: async (req: Request) => {
+            const url = new URL(req.url);
+            return withSecurityHeaders(
+              await handleResidentRead(runtime as ResidentRuntime, req, () =>
+                handleMetadata(store, url)
+              ),
+              isDev
+            );
+          },
+        },
         "/api/tags": {
           GET: async (req: Request) => {
             const url = new URL(req.url);

package/src/serve/spa-production-build.ts

@@ -6,6 +6,8 @@ import { tmpdir } from "node:os";
 // node:path — no Bun path utils.
 import { basename, join, relative } from "node:path";
 
+import { moduleDir, modulePath } from "../core/module-path";
+
 export const ROOT_MOUNT_MARKER = 'getElementById("root")';
 
 export type ProductionSpaFile = {
@@ -19,7 +21,8 @@ export type ProductionSpaAssets = {
   sourceHash: string;
 };
 
-const productionSpaPublicDir = (): string => join(import.meta.dir, "public");
+const productionSpaPublicDir = (): string =>
+  join(moduleDir(import.meta), "public");
 
 export const productionSpaEntryPath = (): string =>
   join(productionSpaPublicDir(), "index.html");
@@ -79,13 +82,14 @@ const contentTypeFor = (path: string): string => {
   return "application/octet-stream";
 };
 
-export const isBunfsPath = (path: string): boolean => {
+export const isBunfsPath = (path: string | undefined): boolean => {
+  if (path === undefined) return false;
   const normalized = path.replaceAll("\\", "/");
   return normalized.includes("/$bunfs/") || normalized.startsWith("B:/~BUN/");
 };
 
 export const isStandaloneExecutable = (): boolean =>
-  isBunfsPath(import.meta.path);
+  isBunfsPath(modulePath(import.meta));
 
 const rewriteProductionHtml = (html: string, jsEntryPath: string): string => {
   const script = `<script type="module" src="/${basename(jsEntryPath)}"></script>`;

package/src/serve/status-model.ts

@@ -28,6 +28,8 @@ export interface StatusCollection {
   documentCount: number;
   chunkCount: number;
   embeddedCount: number;
+  /** Present while the collection root is missing or unreadable (path-free). */
+  rootError?: { code: string; message: string };
 }
 
 export interface SuggestedCollection {

package/src/serve/status.ts

@@ -20,6 +20,10 @@ import {
   type ActivationStatus,
   buildActivationStatus,
 } from "../core/activation-status";
+import {
+  checkCollectionRoots,
+  type CollectionRootError,
+} from "../ingestion/source-availability/root";
 import { ModelCache } from "../llm/cache";
 import { envIsSet, resolveDownloadPolicy } from "../llm/policy";
 import { getActivePreset, resolveModelUri } from "../llm/registry";
@@ -263,6 +267,25 @@ function buildCollectionCheck(status: IndexStatus): HealthCheck {
   };
 }
 
+/** Folders whose root is missing or unreadable right now; null when none. */
+function buildFolderAccessCheck(
+  rootErrors: Record<string, CollectionRootError>
+): HealthCheck | null {
+  const names = Object.keys(rootErrors);
+  if (names.length === 0) {
+    return null;
+  }
+  return {
+    id: "folder-access",
+    title: "Folder access",
+    status: "warn",
+    summary: `${names.join(", ")}: folder missing or unreadable`,
+    detail: `${names.map((name) => `${name}: ${rootErrors[name]?.message}.`).join(" ")} Reconnect the drive or restore the folder; this clears as soon as it is back. If the folder moved, change the collection's path.`,
+    actionLabel: "Manage folders",
+    actionKind: "open-collections",
+  };
+}
+
 function buildIndexingCheck(status: IndexStatus): HealthCheck {
   if (status.recentErrors > 0) {
     return {
@@ -688,6 +711,7 @@ export async function buildAppStatus(
     bootstrap,
     embedCached,
     connectorTargets,
+    rootErrors,
   ] = await Promise.all([
     buildModelCheck(ctx, deps),
     buildDiskCheck(status, deps),
@@ -695,6 +719,7 @@ export async function buildAppStatus(
     buildBootstrapState(ctx),
     isModelCached(preset.embed),
     (deps.listConnectorTargets ?? getConnectorVerificationTargets)(),
+    checkCollectionRoots(ctx.config.collections),
   ]);
   const activation = await (deps.buildActivation ?? buildActivationStatus)(
     ctx.store,
@@ -712,6 +737,7 @@ export async function buildAppStatus(
   const backgroundCheck = buildBackgroundCheck(ctx, status);
   const checks = [
     buildCollectionCheck(status),
+    buildFolderAccessCheck(rootErrors),
     buildIndexingCheck(status),
     buildActivationCheck(activation),
     buildConnectorActivationCheck(activation),
@@ -746,6 +772,9 @@ export async function buildAppStatus(
       documentCount: collection.activeDocuments,
       chunkCount: collection.totalChunks,
       embeddedCount: collection.embeddedChunks,
+      ...(rootErrors[collection.name]
+        ? { rootError: rootErrors[collection.name] }
+        : {}),
     })),
     totalDocuments: status.activeDocuments,
     totalChunks: status.totalChunks,

package/src/sessions/config-refresh.ts

@@ -13,6 +13,7 @@ import type { SqliteAdapter } from "../store/sqlite/adapter";
 import { getIndexDbPath } from "../app/constants";
 import { loadConfig } from "../config";
 import { collectionEgressPolicyEpoch } from "../core/collection-egress-policy-service";
+import { StaleCollectionsError } from "../store/sqlite/adapter";
 import { assertSessionBinding } from "./binding";
 import { SessionsError } from "./types";
 
@@ -76,7 +77,12 @@ export async function adoptServedConfig(
   served: ServedSessionsConfig,
   config: Config
 ): Promise<void> {
+  // A config edit never deletes indexed collections; one it dropped fails
+  // the refresh until it is added back or `gno cleanup` deletes it.
   const collections = await served.store.syncCollections(config.collections);
+  if (!collections.ok && collections.error.code === "STALE_COLLECTIONS") {
+    throw new StaleCollectionsError(collections.error.message);
+  }
   if (!collections.ok) {
     throw new Error(
       `Config saved but collection sync failed: ${collections.error.message}`

package/src/sessions/import-child.ts

@@ -26,6 +26,7 @@ import type { Config } from "../config/types";
 import type { SessionImportReceipt } from "./types";
 
 import { getIndexDbPath } from "../app/constants";
+import { modulePath } from "../core/module-path";
 import { isStandaloneExecutable } from "../serve/spa-production-build";
 import { SqliteAdapter } from "../store/sqlite/adapter";
 import { assertSessionBinding } from "./binding";
@@ -113,7 +114,9 @@ export async function importInChildProcess(
   // Shared check: covers the POSIX `/$bunfs/` and Windows `B:/~BUN/` roots.
   const compiled = isStandaloneExecutable();
   const child = Bun.spawn({
-    cmd: compiled ? [process.execPath] : [process.execPath, import.meta.path],
+    cmd: compiled
+      ? [process.execPath]
+      : [process.execPath, modulePath(import.meta)],
     env: compiled ? { ...process.env, [IMPORT_CHILD_ENV]: "1" } : process.env,
     // The request line, then held open as the child's lifeline.
     stdin: "pipe",