@gmickel/gno 2.7.1 → 2.8.0

package/src/sessions/config-refresh.ts

@@ -0,0 +1,111 @@
+/**
+ * Keep a running server's session-archive config current with its config
+ * file. `gno sessions source add/remove` and automation changes rewrite the
+ * file from another process; the REST routes and the MCP session tools both
+ * re-read it here, binding checked, and adopt it only when it changed.
+ *
+ * @module src/sessions/config-refresh
+ */
+
+import type { Config } from "../config/types";
+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 { assertSessionBinding } from "./binding";
+import { SessionsError } from "./types";
+
+/** The config/index pair a server instance was opened on. */
+export interface SessionsInstance {
+  configPath: string;
+  indexName: string;
+}
+
+/** A running server's served config and the hooks that follow a swap. */
+export interface ServedSessionsConfig extends SessionsInstance {
+  store: SqliteAdapter;
+  config: Config;
+  /** Swap the served config in memory (and anything derived from it). */
+  setConfig: (config: Config) => void;
+  invalidateEgressPolicy?: () => Promise<unknown>;
+  markContentMutation?: () => void;
+  markIndexMutation?: () => void;
+}
+
+/** Refuse an archive config opened against a different index (and vice versa). */
+export async function assertInstanceBinding(
+  instance: SessionsInstance,
+  config: Config
+): Promise<void> {
+  if (!config.sessions) return;
+  await assertSessionBinding({
+    config,
+    configPath: instance.configPath,
+    indexName: instance.indexName,
+    dbPath: getIndexDbPath(instance.indexName),
+  });
+}
+
+/**
+ * Read this instance's config file, binding checked: unreadable is an error,
+ * never served stale, and a config rebound to another index is refused
+ * before it can touch this one.
+ */
+export async function readInstanceConfig(
+  instance: SessionsInstance
+): Promise<Config> {
+  const loaded = await loadConfig(instance.configPath);
+  if (!loaded.ok) {
+    throw new SessionsError(
+      "SESSIONS_RUNTIME_FAILURE",
+      "The server could not read its config file; fix the file (gno doctor shows the error) and reload."
+    );
+  }
+  await assertInstanceBinding(instance, loaded.value);
+  return loaded.value;
+}
+
+/**
+ * Adopt a config already persisted to the file: project collections and
+ * contexts into the open store, swap the served config, then refresh the
+ * egress policy (only when it changed) and mutation generations.
+ */
+export async function adoptServedConfig(
+  served: ServedSessionsConfig,
+  config: Config
+): Promise<void> {
+  const collections = await served.store.syncCollections(config.collections);
+  if (!collections.ok) {
+    throw new Error(
+      `Config saved but collection sync failed: ${collections.error.message}`
+    );
+  }
+  const contexts = await served.store.syncContexts(config.contexts ?? []);
+  if (!contexts.ok) {
+    throw new Error(
+      `Config saved but context sync failed: ${contexts.error.message}`
+    );
+  }
+  const policyChanged =
+    collectionEgressPolicyEpoch(config) !==
+    collectionEgressPolicyEpoch(served.config);
+  served.setConfig(config);
+  if (policyChanged) await served.invalidateEgressPolicy?.();
+  served.markContentMutation?.();
+  served.markIndexMutation?.();
+}
+
+/**
+ * Adopt the config file when it changed underneath the running server.
+ * Returns the config to serve; throws a `SessionsError` when the file is
+ * unreadable or bound to another index, leaving the served config as it was.
+ */
+export async function refreshServedConfig(
+  served: ServedSessionsConfig
+): Promise<Config> {
+  const config = await readInstanceConfig(served);
+  if (Bun.deepEquals(config, served.config)) return served.config;
+  await adoptServedConfig(served, config);
+  return config;
+}

package/src/store/migrations/033-drop-documents-active-index.ts

@@ -0,0 +1,30 @@
+/**
+ * Migration: drop the low-selectivity documents(active) index.
+ *
+ * GNO keeps no planner statistics, so SQLite treated `idx_documents_active`
+ * (matching nearly every row) as a peer of selective indexes and chose it
+ * for `<column> = ? AND active = 1` lookups, turning point lookups and
+ * per-chunk EXISTS probes into whole-table walks. No query filters on
+ * inactive documents, so the index serves no lookup.
+ *
+ * @module src/store/migrations/033-drop-documents-active-index
+ */
+
+import type { Database } from "bun:sqlite";
+
+import type { Migration } from "./runner";
+
+export const migration: Migration = {
+  version: 33,
+  name: "drop_documents_active_index",
+
+  up(db: Database): void {
+    db.exec("DROP INDEX IF EXISTS idx_documents_active");
+  },
+
+  down(db: Database): void {
+    db.exec(
+      "CREATE INDEX IF NOT EXISTS idx_documents_active ON documents(active)"
+    );
+  },
+};

package/src/store/migrations/034-collection-link-workspace.ts

@@ -0,0 +1,47 @@
+/**
+ * Store each collection's effective link workspace (derived from the
+ * filesystem at config sync) so query-time link resolution, status output
+ * and graph projection fingerprints read one consistent membership.
+ */
+import type { Migration } from "./runner";
+
+const COLUMNS: Array<[string, string]> = [
+  ["real_path", "TEXT"],
+  ["workspace_root", "TEXT"],
+  [
+    "workspace_source",
+    "TEXT NOT NULL DEFAULT 'none' CHECK (workspace_source IN ('none', 'detected', 'configured', 'disabled', 'unavailable'))",
+  ],
+  ["workspace_nested", "TEXT"],
+];
+
+const existingColumns = (db: Parameters<Migration["up"]>[0]): Set<string> =>
+  new Set(
+    db
+      .query<{ name: string }, []>("PRAGMA table_info(collections)")
+      .all()
+      .map((row) => row.name)
+  );
+
+export const migration: Migration = {
+  version: 34,
+  name: "collection_link_workspace",
+
+  up(db): void {
+    const columns = existingColumns(db);
+    for (const [name, definition] of COLUMNS) {
+      if (!columns.has(name)) {
+        db.exec(`ALTER TABLE collections ADD COLUMN ${name} ${definition}`);
+      }
+    }
+  },
+
+  down(db): void {
+    const columns = existingColumns(db);
+    for (const [name] of [...COLUMNS].reverse()) {
+      if (columns.has(name)) {
+        db.exec(`ALTER TABLE collections DROP COLUMN ${name}`);
+      }
+    }
+  },
+};

package/src/store/migrations/index.ts

@@ -46,6 +46,8 @@ import { migration as m029 } from "./029-graph-reference-state";
 import { migration as m030 } from "./030-typed-metadata";
 import { migration as m031 } from "./031-runtime-independent-vectors";
 import { migration as m032 } from "./032-vector-runtime-callers";
+import { migration as m033 } from "./033-drop-documents-active-index";
+import { migration as m034 } from "./034-collection-link-workspace";
 
 /** All migrations in order */
 export const migrations = [
@@ -81,4 +83,6 @@ export const migrations = [
   m030,
   m031,
   m032,
+  m033,
+  m034,
 ];