@gmickel/gno 0.29.1 → 0.30.0

package/README.md

@@ -39,6 +39,13 @@ GNO is a local knowledge engine that turns your documents into a searchable, con
 - **GNO Desktop Beta**: first mac-first desktop beta shell with deep-link routing, singleton handoff, and the same onboarding/search/edit flows as `gno serve`
 - **Desktop Onboarding Polish**: guided setup now covers folders, presets, model readiness, indexing, connectors, import preview, app tabs, file actions, and recovery without drift between web and desktop
 - **Default Preset Upgrade**: `slim-tuned` is now the built-in default, using the fine-tuned retrieval expansion model while keeping the same embed, rerank, and answer stack as `slim`
+- **Workspace UI Polish**: richer scholarly-dusk presentation across dashboard, tabs, search, ask, footer, and global styling without introducing external font or asset dependencies
+
+## What's New in v0.30
+
+- **Headless Daemon Mode**: `gno daemon` keeps your index fresh continuously without opening the Web UI
+- **CLI Concurrency Hardening**: read-only commands no longer trip transient `database is locked` errors when they overlap with `gno update`
+- **Web/Desktop UI Polish**: sharper workspace styling across dashboard, tabs, search, ask, and footer surfaces
 
 ### v0.24
 
@@ -144,6 +151,7 @@ gno query "ECONNREFUSED 127.0.0.1:5432" --thorough
 ```bash
 gno init ~/notes --name notes    # Point at your docs
 gno index                        # Build search index
+gno daemon                       # Keep index fresh in background (foreground process)
 gno query "auth best practices"  # Hybrid search
 gno ask "summarize the API" --answer  # AI answer with citations
 ```
@@ -174,6 +182,15 @@ Verify everything works:
 gno doctor
 ```
 
+Keep an index fresh continuously without opening the Web UI:
+
+```bash
+gno daemon
+```
+
+`gno daemon` runs as a foreground watcher/sync/embed process. Use `nohup`,
+launchd, or systemd if you want it supervised long-term.
+
 ### Connect to AI Agents
 
 #### MCP Server (Claude Desktop, Cursor, Zed, etc.)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gmickel/gno",
-  "version": "0.29.1",
+  "version": "0.30.0",
   "description": "Local semantic search for your documents. Index Markdown, PDF, and Office files with hybrid BM25 + vector search.",
   "keywords": [
     "embeddings",

package/src/cli/commands/ask.ts

@@ -75,6 +75,7 @@ export async function ask(
   const initResult = await initStore({
     configPath: options.configPath,
     collection: options.collection,
+    syncConfig: false,
   });
 
   if (!initResult.ok) {

package/src/cli/commands/completion/scripts.ts

@@ -28,6 +28,7 @@ const COMMANDS = [
   "get",
   "multi-get",
   "ls",
+  "daemon",
   "serve",
   "mcp",
   "mcp serve",
@@ -330,6 +331,7 @@ function getCommandDescription(cmd: string): string {
     get: "Get document by URI",
     "multi-get": "Get multiple documents",
     ls: "List indexed documents",
+    daemon: "Start headless continuous indexing",
     serve: "Start web UI server",
     mcp: "MCP server and configuration",
     "mcp serve": "Start MCP server",

package/src/cli/commands/daemon.ts

@@ -0,0 +1,159 @@
+import type { CollectionSyncResult } from "../../ingestion";
+import type { BackgroundRuntimeResult } from "../../serve/background-runtime";
+
+import { startBackgroundRuntime } from "../../serve/background-runtime";
+
+export interface DaemonOptions {
+  configPath?: string;
+  index?: string;
+  offline?: boolean;
+  verbose?: boolean;
+  quiet?: boolean;
+  noSyncOnStart?: boolean;
+  signal?: AbortSignal;
+}
+
+export type DaemonResult =
+  | { success: true }
+  | { success: false; error: string };
+
+type DaemonLogger = {
+  log: (message: string) => void;
+  error: (message: string) => void;
+};
+
+type DaemonDeps = {
+  startBackgroundRuntime?: typeof startBackgroundRuntime;
+  logger?: DaemonLogger;
+};
+
+function formatCollectionSyncSummary(result: CollectionSyncResult): string {
+  return `${result.collection}: ${result.filesAdded} added, ${result.filesUpdated} updated, ${result.filesUnchanged} unchanged, ${result.filesErrored} errors`;
+}
+
+function createSignalPromise(
+  signal: AbortSignal | undefined,
+  logger: DaemonLogger,
+  quiet: boolean
+): Promise<void> {
+  return new Promise((resolve) => {
+    if (signal?.aborted) {
+      resolve();
+      return;
+    }
+
+    const complete = (message?: string): void => {
+      signal?.removeEventListener("abort", onAbort);
+      process.off("SIGINT", onSigint);
+      process.off("SIGTERM", onSigterm);
+      if (message && !quiet) {
+        logger.log(message);
+      }
+      resolve();
+    };
+
+    const onAbort = (): void => complete("Daemon stopped.");
+    const onSigint = (): void => complete("Received SIGINT. Shutting down...");
+    const onSigterm = (): void =>
+      complete("Received SIGTERM. Shutting down...");
+
+    signal?.addEventListener("abort", onAbort, { once: true });
+    process.once("SIGINT", onSigint);
+    process.once("SIGTERM", onSigterm);
+  });
+}
+
+export async function daemon(
+  options: DaemonOptions = {},
+  deps: DaemonDeps = {}
+): Promise<DaemonResult> {
+  const logger = deps.logger ?? {
+    log: (message: string) => {
+      console.log(message);
+    },
+    error: (message: string) => {
+      console.error(message);
+    },
+  };
+
+  const runtimeResult: BackgroundRuntimeResult = await (
+    deps.startBackgroundRuntime ?? startBackgroundRuntime
+  )({
+    configPath: options.configPath,
+    index: options.index,
+    requireCollections: true,
+    offline: options.offline,
+    watchCallbacks: {
+      onSyncStart: ({ collection, relPaths }) => {
+        if (!options.quiet) {
+          logger.log(
+            `watch sync started: ${collection} (${relPaths.length} path${relPaths.length === 1 ? "" : "s"})`
+          );
+        }
+      },
+      onSyncComplete: ({ result }) => {
+        if (!options.quiet) {
+          logger.log(formatCollectionSyncSummary(result));
+        }
+      },
+      onSyncError: ({ collection, error }) => {
+        logger.error(
+          `watch sync failed: ${collection}: ${error instanceof Error ? error.message : String(error)}`
+        );
+      },
+    },
+  });
+  if (!runtimeResult.success) {
+    return { success: false, error: runtimeResult.error };
+  }
+
+  const { runtime } = runtimeResult;
+  try {
+    if (!options.quiet) {
+      logger.log(
+        `GNO daemon started for index "${options.index ?? "default"}" using ${runtime.config.collections.length} collection${runtime.config.collections.length === 1 ? "" : "s"}.`
+      );
+      const watchState = runtime.watchService.getState();
+      if (watchState.activeCollections.length > 0) {
+        logger.log(`watching: ${watchState.activeCollections.join(", ")}`);
+      }
+      if (watchState.failedCollections.length > 0) {
+        for (const failed of watchState.failedCollections) {
+          logger.error(`watch failed: ${failed.collection}: ${failed.reason}`);
+        }
+      }
+    }
+
+    if (!options.noSyncOnStart) {
+      if (!options.quiet) {
+        logger.log("Running initial sync...");
+      }
+      const { syncResult, embedResult } = await runtime.syncAll({
+        runUpdateCmd: true,
+        triggerEmbed: true,
+      });
+      if (!options.quiet) {
+        logger.log(
+          `sync totals: ${syncResult.totalFilesAdded} added, ${syncResult.totalFilesUpdated} updated, ${syncResult.totalFilesErrored} errors, ${syncResult.totalFilesSkipped} skipped`
+        );
+      }
+      if (!options.quiet && embedResult) {
+        logger.log(
+          `embed: ${embedResult.embedded} embedded, ${embedResult.errors} errors`
+        );
+      }
+    } else if (!options.quiet) {
+      logger.log("Skipping initial sync (--no-sync-on-start).");
+    }
+
+    await createSignalPromise(options.signal, logger, options.quiet ?? false);
+    return { success: true };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error),
+    };
+  } finally {
+    await runtime.dispose();
+  }
+}

package/src/cli/commands/get.ts

@@ -110,7 +110,10 @@ export async function get(
     return { success: false, error: parsed.error, isValidation: true };
   }
 
-  const initResult = await initStore({ configPath: options.configPath });
+  const initResult = await initStore({
+    configPath: options.configPath,
+    syncConfig: false,
+  });
   if (!initResult.ok) {
     return { success: false, error: initResult.error };
   }

package/src/cli/commands/graph.ts

@@ -49,7 +49,10 @@ export type GraphCommandResult =
 export async function graph(
   options: GraphOptions = {}
 ): Promise<GraphCommandResult> {
-  const initResult = await initStore({ configPath: options.configPath });
+  const initResult = await initStore({
+    configPath: options.configPath,
+    syncConfig: false,
+  });
   if (!initResult.ok) {
     return { success: false, error: initResult.error };
   }

package/src/cli/commands/links.ts

@@ -315,7 +315,10 @@ export async function linksList(
   docRef: string,
   options: LinksListOptions = {}
 ): Promise<LinksListResult> {
-  const initResult = await initStore({ configPath: options.configPath });
+  const initResult = await initStore({
+    configPath: options.configPath,
+    syncConfig: false,
+  });
   if (!initResult.ok) {
     return { success: false, error: initResult.error };
   }
@@ -428,7 +431,10 @@ export async function backlinks(
   docRef: string,
   options: BacklinksOptions = {}
 ): Promise<BacklinksResult> {
-  const initResult = await initStore({ configPath: options.configPath });
+  const initResult = await initStore({
+    configPath: options.configPath,
+    syncConfig: false,
+  });
   if (!initResult.ok) {
     return { success: false, error: initResult.error };
   }
@@ -507,7 +513,10 @@ export async function similar(
   const threshold = options.threshold ?? 0.7;
   const crossCollection = options.crossCollection ?? false;
 
-  const initResult = await initStore({ configPath: options.configPath });
+  const initResult = await initStore({
+    configPath: options.configPath,
+    syncConfig: false,
+  });
   if (!initResult.ok) {
     return { success: false, error: initResult.error };
   }

package/src/cli/commands/ls.ts

@@ -109,7 +109,10 @@ export async function ls(
     }
   }
 
-  const initResult = await initStore({ configPath: options.configPath });
+  const initResult = await initStore({
+    configPath: options.configPath,
+    syncConfig: false,
+  });
   if (!initResult.ok) {
     return { success: false, error: initResult.error };
   }

package/src/cli/commands/multi-get.ts

@@ -250,7 +250,10 @@ export async function multiGet(
   const maxBytes = options.maxBytes ?? 10_240;
   const allRefs = splitRefs(refs);
 
-  const initResult = await initStore({ configPath: options.configPath });
+  const initResult = await initStore({
+    configPath: options.configPath,
+    syncConfig: false,
+  });
   if (!initResult.ok) {
     return { success: false, error: initResult.error };
   }

package/src/cli/commands/query.ts

@@ -83,6 +83,7 @@ export async function query(
   const initResult = await initStore({
     configPath: options.configPath,
     collection: options.collection,
+    syncConfig: false,
   });
 
   if (!initResult.ok) {

package/src/cli/commands/search.ts

@@ -56,6 +56,7 @@ export async function search(
   const initResult = await initStore({
     configPath: options.configPath,
     collection: options.collection,
+    syncConfig: false,
   });
 
   if (!initResult.ok) {

package/src/cli/commands/shared.ts

@@ -36,6 +36,8 @@ export interface InitStoreOptions {
   indexName?: string;
   /** Filter to single collection by name */
   collection?: string;
+  /** Sync collections/contexts from config into DB on open */
+  syncConfig?: boolean;
 }
 
 /**
@@ -99,6 +101,10 @@ export async function initStore(
     return { ok: false, error: openResult.error.message };
   }
 
+  if (options.syncConfig === false) {
+    return { ok: true, store, config, collections, actualConfigPath };
+  }
+
   // Sync collections from config to DB
   const syncCollResult = await store.syncCollections(config.collections);
   if (!syncCollResult.ok) {

package/src/cli/commands/vsearch.ts

@@ -65,6 +65,7 @@ export async function vsearch(
   const initResult = await initStore({
     configPath: options.configPath,
     collection: options.collection,
+    syncConfig: false,
   });
 
   if (!initResult.ok) {

package/src/cli/program.ts

@@ -188,6 +188,7 @@ export function createProgram(): Command {
   wireGraphCommand(program);
   wireMcpCommand(program);
   wireSkillCommands(program);
+  wireDaemonCommand(program);
   wireServeCommand(program);
   wireCompletionCommand(program);
 
@@ -2038,6 +2039,31 @@ function wireGraphCommand(program: Command): void {
 // Serve Command (web UI)
 // ─────────────────────────────────────────────────────────────────────────────
 
+function wireDaemonCommand(program: Command): void {
+  program
+    .command("daemon")
+    .description("Start headless continuous indexing")
+    .option(
+      "--no-sync-on-start",
+      "skip initial sync and only watch future file changes"
+    )
+    .action(async (cmdOpts: Record<string, unknown>) => {
+      const globals = getGlobals();
+      const { daemon } = await import("./commands/daemon.js");
+      const result = await daemon({
+        configPath: globals.config,
+        index: globals.index,
+        offline: globals.offline,
+        verbose: globals.verbose,
+        quiet: globals.quiet,
+        noSyncOnStart: cmdOpts.syncOnStart === false,
+      });
+      if (!result.success) {
+        throw new CliError("RUNTIME", result.error);
+      }
+    });
+}
+
 function wireServeCommand(program: Command): void {
   program
     .command("serve")

package/src/serve/background-runtime.ts

@@ -0,0 +1,219 @@
+import type { Config } from "../config/types";
+import type { SyncResult } from "../ingestion";
+import type { DocumentEventBus } from "./doc-events";
+import type { EmbedResult, EmbedScheduler } from "./embed-scheduler";
+import type { ContextHolder } from "./routes/api";
+import type {
+  CollectionWatchCallbacks,
+  CollectionWatchService,
+} from "./watch-service";
+
+import { getIndexDbPath } from "../app/constants";
+import {
+  ensureDirectories,
+  getConfigPaths,
+  isInitialized,
+  loadConfig,
+} from "../config";
+import { defaultSyncService } from "../ingestion";
+import { getActivePreset } from "../llm/registry";
+import { SqliteAdapter } from "../store/sqlite/adapter";
+import {
+  createServerContext,
+  type CreateServerContextOptions,
+  disposeServerContext,
+  type ServerContext,
+} from "./context";
+import { createEmbedScheduler } from "./embed-scheduler";
+import { CollectionWatchService as DefaultCollectionWatchService } from "./watch-service";
+
+export interface BackgroundRuntimeOptions {
+  configPath?: string;
+  index?: string;
+  requireCollections?: boolean;
+  offline?: boolean;
+  eventBus?: DocumentEventBus | null;
+  watchCallbacks?: CollectionWatchCallbacks;
+}
+
+export interface BackgroundRuntime {
+  store: SqliteAdapter;
+  config: Config;
+  actualConfigPath: string;
+  ctxHolder: ContextHolder;
+  scheduler: EmbedScheduler;
+  eventBus: DocumentEventBus | null;
+  watchService: CollectionWatchService;
+  syncAll(options?: {
+    gitPull?: boolean;
+    runUpdateCmd?: boolean;
+    triggerEmbed?: boolean;
+  }): Promise<{
+    syncResult: SyncResult;
+    embedResult: EmbedResult | null;
+  }>;
+  dispose(): Promise<void>;
+}
+
+export type BackgroundRuntimeResult =
+  | { success: true; runtime: BackgroundRuntime }
+  | { success: false; error: string };
+
+type BackgroundRuntimeDeps = {
+  isInitialized?: typeof isInitialized;
+  loadConfig?: typeof loadConfig;
+  getConfigPaths?: typeof getConfigPaths;
+  ensureDirectories?: typeof ensureDirectories;
+  storeFactory?: () => SqliteAdapter;
+  createServerContext?: (
+    store: SqliteAdapter,
+    config: Config,
+    options?: CreateServerContextOptions
+  ) => Promise<ServerContext>;
+  disposeServerContext?: (ctx: ServerContext) => Promise<void>;
+  createEmbedScheduler?: typeof createEmbedScheduler;
+  syncAllService?: typeof defaultSyncService.syncAll;
+  watchServiceFactory?: (options: {
+    collections: Config["collections"];
+    store: SqliteAdapter;
+    scheduler: EmbedScheduler | null;
+    eventBus?: DocumentEventBus | null;
+    callbacks?: CollectionWatchCallbacks;
+  }) => CollectionWatchService;
+};
+
+export async function startBackgroundRuntime(
+  options: BackgroundRuntimeOptions = {},
+  deps: BackgroundRuntimeDeps = {}
+): Promise<BackgroundRuntimeResult> {
+  const syncAllService = deps.syncAllService
+    ? (...args: Parameters<typeof defaultSyncService.syncAll>) =>
+        deps.syncAllService!(...args)
+    : defaultSyncService.syncAll.bind(defaultSyncService);
+  const initialized = await (deps.isInitialized ?? isInitialized)(
+    options.configPath
+  );
+  if (!initialized) {
+    return { success: false, error: "GNO not initialized. Run: gno init" };
+  }
+
+  const configResult = await (deps.loadConfig ?? loadConfig)(
+    options.configPath
+  );
+  if (!configResult.ok) {
+    return { success: false, error: configResult.error.message };
+  }
+  const config = configResult.value;
+
+  if (options.requireCollections && config.collections.length === 0) {
+    return {
+      success: false,
+      error: "No collections configured. Run: gno collection add <path>",
+    };
+  }
+
+  await (deps.ensureDirectories ?? ensureDirectories)();
+
+  const store = deps.storeFactory ? deps.storeFactory() : new SqliteAdapter();
+  const dbPath = getIndexDbPath(options.index);
+  const paths = (deps.getConfigPaths ?? getConfigPaths)();
+  const actualConfigPath = options.configPath ?? paths.configFile;
+  store.setConfigPath(actualConfigPath);
+
+  const openResult = await store.open(dbPath, config.ftsTokenizer);
+  if (!openResult.ok) {
+    return { success: false, error: openResult.error.message };
+  }
+
+  const syncCollResult = await store.syncCollections(config.collections);
+  if (!syncCollResult.ok) {
+    await store.close();
+    return { success: false, error: syncCollResult.error.message };
+  }
+  const syncCtxResult = await store.syncContexts(config.contexts ?? []);
+  if (!syncCtxResult.ok) {
+    await store.close();
+    return { success: false, error: syncCtxResult.error.message };
+  }
+
+  const ctx = await (deps.createServerContext ?? createServerContext)(
+    store,
+    config,
+    {
+      offline: options.offline ?? false,
+    }
+  );
+
+  const ctxHolder: ContextHolder = {
+    current: ctx,
+    config,
+    scheduler: null,
+    eventBus: options.eventBus ?? null,
+    watchService: null,
+  };
+
+  const scheduler = (deps.createEmbedScheduler ?? createEmbedScheduler)({
+    db: store.getRawDb(),
+    getEmbedPort: () => ctxHolder.current.embedPort,
+    getVectorIndex: () => ctxHolder.current.vectorIndex,
+    getModelUri: () => getActivePreset(ctxHolder.config).embed,
+  });
+  ctxHolder.scheduler = scheduler;
+  ctxHolder.current.scheduler = scheduler;
+  ctxHolder.current.eventBus = options.eventBus ?? null;
+
+  const watchService = (
+    deps.watchServiceFactory ??
+    ((watchOptions) => new DefaultCollectionWatchService(watchOptions))
+  )({
+    collections: config.collections,
+    store,
+    scheduler,
+    eventBus: options.eventBus ?? null,
+    callbacks: options.watchCallbacks,
+  });
+  watchService.start();
+  ctxHolder.watchService = watchService;
+  ctxHolder.current.watchService = watchService;
+
+  let disposed = false;
+
+  return {
+    success: true,
+    runtime: {
+      store,
+      config,
+      actualConfigPath,
+      ctxHolder,
+      scheduler,
+      eventBus: options.eventBus ?? null,
+      watchService,
+      async syncAll(syncOptions = {}) {
+        const syncResult = await syncAllService(config.collections, store, {
+          gitPull: syncOptions.gitPull,
+          runUpdateCmd: syncOptions.runUpdateCmd,
+        });
+
+        let embedResult: EmbedResult | null = null;
+        if (syncOptions.triggerEmbed !== false) {
+          embedResult = await scheduler.triggerNow();
+        }
+
+        return { syncResult, embedResult };
+      },
+      async dispose() {
+        if (disposed) {
+          return;
+        }
+        disposed = true;
+        await Promise.resolve(watchService.dispose());
+        options.eventBus?.close();
+        scheduler.dispose();
+        await (deps.disposeServerContext ?? disposeServerContext)(
+          ctxHolder.current
+        );
+        await store.close();
+      },
+    },
+  };
+}

package/src/serve/context.ts

@@ -80,13 +80,18 @@ export interface ServerContext {
   watchService?: CollectionWatchService | null;
 }
 
+export interface CreateServerContextOptions {
+  offline?: boolean;
+}
+
 /**
  * Initialize server context with LLM ports.
  * Attempts to load models; missing models are logged but don't fail.
  */
 export async function createServerContext(
   store: SqliteAdapter,
-  config: Config
+  config: Config,
+  options: CreateServerContextOptions = {}
 ): Promise<ServerContext> {
   let embedPort: EmbeddingPort | null = null;
   let expandPort: GenerationPort | null = null;
@@ -99,7 +104,9 @@ export async function createServerContext(
     const llm = new LlmAdapter(config);
 
     // Resolve download policy from env (serve has no CLI flags)
-    const policy = resolveDownloadPolicy(process.env, {});
+    const policy = resolveDownloadPolicy(process.env, {
+      offline: options.offline ?? false,
+    });
 
     // Progress callback updates downloadState for WebUI polling
     const createPortOptions = (type: ModelType): CreatePortOptions => ({
@@ -231,8 +238,9 @@ export async function disposeServerContext(ctx: ServerContext): Promise<void> {
  */
 export async function reloadServerContext(
   ctx: ServerContext,
-  newConfig?: Config
+  newConfig?: Config,
+  options: CreateServerContextOptions = {}
 ): Promise<ServerContext> {
   await disposeServerContext(ctx);
-  return createServerContext(ctx.store, newConfig ?? ctx.config);
+  return createServerContext(ctx.store, newConfig ?? ctx.config, options);
 }

package/src/serve/index.ts

@@ -5,3 +5,9 @@
  */
 
 export { type ServeOptions, type ServeResult, startServer } from "./server";
+export {
+  type BackgroundRuntime,
+  type BackgroundRuntimeOptions,
+  type BackgroundRuntimeResult,
+  startBackgroundRuntime,
+} from "./background-runtime";