@gmickel/gno 0.29.0 → 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.0",
+  "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/core/file-ops.ts

@@ -5,11 +5,11 @@
  */
 
 // node:fs/promises for rename/unlink (no Bun equivalent for structure ops)
-import { rename, unlink } from "node:fs/promises";
-// node:os platform: no Bun equivalent
-import { platform } from "node:os";
-// node:path dirname: no Bun equivalent
-import { dirname } from "node:path";
+import { mkdir, rename, unlink } from "node:fs/promises";
+// node:os platform/homedir/tmpdir: no Bun equivalent
+import { homedir, platform as getPlatform, tmpdir } from "node:os";
+// node:path dirname/join/parse: no Bun equivalent
+import { dirname, join, parse } from "node:path";
 
 export async function atomicWrite(
   path: string,
@@ -48,12 +48,176 @@ export async function renameFilePath(
   await rename(currentPath, nextPath);
 }
 
-export async function trashFilePath(path: string): Promise<void> {
-  await runCommand(["trash", path]);
+type TrashFileDeps = {
+  homeDir?: string;
+  platform?: ReturnType<typeof getPlatform>;
+  runCommand?: typeof runCommand;
+  tempDir?: string;
+};
+
+function isCrossDeviceRenameError(
+  error: unknown
+): error is NodeJS.ErrnoException {
+  return (
+    error instanceof Error &&
+    "code" in error &&
+    typeof error.code === "string" &&
+    error.code === "EXDEV"
+  );
+}
+
+async function nextAvailableTrashPath(
+  trashDir: string,
+  sourcePath: string
+): Promise<string> {
+  const { ext, name, base } = parse(sourcePath);
+  let candidate = join(trashDir, base);
+  let suffix = 2;
+  while (await Bun.file(candidate).exists()) {
+    candidate = join(trashDir, `${name} ${suffix}${ext}`);
+    suffix += 1;
+  }
+  return candidate;
+}
+
+async function moveFilePath(
+  sourcePath: string,
+  targetPath: string
+): Promise<void> {
+  try {
+    await rename(sourcePath, targetPath);
+    return;
+  } catch (error) {
+    if (!isCrossDeviceRenameError(error)) {
+      throw error;
+    }
+  }
+
+  await Bun.write(targetPath, Bun.file(sourcePath));
+  await unlink(sourcePath);
+}
+
+async function trashFilePathOnDarwin(
+  path: string,
+  homeDir: string
+): Promise<void> {
+  const trashDir = join(homeDir, ".Trash");
+  await mkdir(trashDir, { recursive: true });
+  const targetPath = await nextAvailableTrashPath(trashDir, path);
+  await moveFilePath(path, targetPath);
+}
+
+function encodeTrashInfoPath(path: string): string {
+  return path
+    .split("/")
+    .map((segment, index) =>
+      index === 0 && segment.length === 0 ? "" : encodeURIComponent(segment)
+    )
+    .join("/");
+}
+
+async function trashFilePathOnLinux(
+  path: string,
+  homeDir: string
+): Promise<void> {
+  const trashRoot = join(homeDir, ".local", "share", "Trash");
+  const filesDir = join(trashRoot, "files");
+  const infoDir = join(trashRoot, "info");
+  await mkdir(filesDir, { recursive: true });
+  await mkdir(infoDir, { recursive: true });
+
+  const targetPath = await nextAvailableTrashPath(filesDir, path);
+  const infoPath = join(infoDir, `${parse(targetPath).base}.trashinfo`);
+  const infoContent = [
+    "[Trash Info]",
+    `Path=${encodeTrashInfoPath(path)}`,
+    `DeletionDate=${new Date().toISOString().slice(0, 19)}`,
+    "",
+  ].join("\n");
+
+  await moveFilePath(path, targetPath);
+  try {
+    await Bun.write(infoPath, infoContent);
+  } catch (error) {
+    await moveFilePath(targetPath, path).catch(() => {
+      /* ignore rollback errors */
+    });
+    throw error;
+  }
+}
+
+async function trashFilePathOnWindows(
+  path: string,
+  deps: Required<Pick<TrashFileDeps, "runCommand" | "tempDir">>
+): Promise<void> {
+  const scriptPath = join(deps.tempDir, `gno-trash-${crypto.randomUUID()}.ps1`);
+  const script = `param([string]$LiteralPath)
+Add-Type -AssemblyName Microsoft.VisualBasic
+if (Test-Path -LiteralPath $LiteralPath -PathType Container) {
+  [Microsoft.VisualBasic.FileIO.FileSystem]::DeleteDirectory(
+    $LiteralPath,
+    [Microsoft.VisualBasic.FileIO.UIOption]::OnlyErrorDialogs,
+    [Microsoft.VisualBasic.FileIO.RecycleOption]::SendToRecycleBin
+  )
+} else {
+  [Microsoft.VisualBasic.FileIO.FileSystem]::DeleteFile(
+    $LiteralPath,
+    [Microsoft.VisualBasic.FileIO.UIOption]::OnlyErrorDialogs,
+    [Microsoft.VisualBasic.FileIO.RecycleOption]::SendToRecycleBin
+  )
+}
+`;
+
+  await Bun.write(scriptPath, script);
+  try {
+    await deps.runCommand([
+      "powershell",
+      "-NoProfile",
+      "-ExecutionPolicy",
+      "Bypass",
+      "-File",
+      scriptPath,
+      path,
+    ]);
+  } finally {
+    await unlink(scriptPath).catch(() => {
+      /* ignore cleanup errors */
+    });
+  }
+}
+
+export async function trashFilePath(
+  path: string,
+  deps: TrashFileDeps = {}
+): Promise<void> {
+  const platform = deps.platform ?? getPlatform();
+  const homeDir = deps.homeDir ?? homedir();
+  const runner = deps.runCommand ?? runCommand;
+  const tempDir = deps.tempDir ?? tmpdir();
+
+  if (platform === "darwin") {
+    await trashFilePathOnDarwin(path, homeDir);
+    return;
+  }
+
+  if (platform === "linux") {
+    await trashFilePathOnLinux(path, homeDir);
+    return;
+  }
+
+  if (platform === "win32") {
+    await trashFilePathOnWindows(path, {
+      runCommand: runner,
+      tempDir,
+    });
+    return;
+  }
+
+  throw new Error(`Trash is not supported on platform: ${platform}`);
 }
 
 export async function revealFilePath(path: string): Promise<void> {
-  if (platform() === "darwin") {
+  if (getPlatform() === "darwin") {
     await runCommand(["open", "-R", path]);
     return;
   }