@gmickel/gno 1.23.0 → 1.25.1

package/src/core/capture.ts

@@ -10,6 +10,10 @@
 import { posix as pathPosix } from "node:path";
 
 import { buildUri } from "../app/constants";
+import {
+  browserClipProvenanceSchema,
+  type BrowserClipProvenance,
+} from "./browser-clip-provenance";
 import {
   resolveNoteCreatePlan,
   type NoteCollisionPolicy,
@@ -59,9 +63,13 @@ export interface CaptureSource {
   mime?: string;
   ext?: string;
   author?: string;
+  canonicalUrl?: string;
+  site?: string;
+  publishedAt?: string;
   observedAt?: string;
   capturedAt: string;
   externalId?: string;
+  browserClip?: BrowserClipProvenance;
 }
 
 export interface CaptureIndexStatus {
@@ -117,6 +125,7 @@ export interface CapturePlan {
   source: CaptureSource;
   openedExisting: boolean;
   createdWithSuffix: boolean;
+  provenanceConflict: boolean;
   collisionPolicy: NoteCollisionPolicy;
   collisionPolicyResult: CaptureCollisionPolicyResult;
   overwrite: boolean;
@@ -126,6 +135,7 @@ export interface PlanCaptureOptions {
   input: CaptureInput;
   existingRelPaths: Iterable<string>;
   diskRelPaths?: Iterable<string>;
+  existingProvenanceByRelPath?: ReadonlyMap<string, string>;
   now?: Date;
 }
 
@@ -145,7 +155,7 @@ const VALID_COLLISION_POLICIES = new Set<NoteCollisionPolicy>([
   "open_existing",
   "create_with_suffix",
 ]);
-const URL_SOURCE_FIELDS = new Set(["url", "uri"]);
+const URL_SOURCE_FIELDS = new Set(["url", "uri", "canonicalUrl"]);
 const LEGACY_SOURCE_FIELD_MAP: Record<string, keyof CaptureSource> = {
   gno_source_docid: "docid",
   gno_source_uri: "uri",
@@ -160,6 +170,9 @@ const CAPTURE_SOURCE_STRING_KEYS = new Set([
   "mime",
   "ext",
   "author",
+  "canonicalUrl",
+  "site",
+  "publishedAt",
   "externalId",
 ]);
 
@@ -264,27 +277,46 @@ function normalizeSource(
       continue;
     }
     if (key === "capturedAt") {
-      normalized.capturedAt = normalizeIsoDate(
-        String(value),
-        "source.capturedAt"
-      );
+      if (typeof value !== "string") {
+        throw new Error("source.capturedAt must be a string.");
+      }
+      normalized.capturedAt = normalizeIsoDate(value, "source.capturedAt");
       continue;
     }
     if (key === "observedAt") {
-      normalized.observedAt = normalizeIsoDate(
-        String(value),
-        "source.observedAt"
-      );
+      if (typeof value !== "string") {
+        throw new Error("source.observedAt must be a string.");
+      }
+      normalized.observedAt = normalizeIsoDate(value, "source.observedAt");
+      continue;
+    }
+    if (key === "publishedAt") {
+      if (typeof value !== "string") {
+        throw new Error("source.publishedAt must be a string.");
+      }
+      normalized.publishedAt = /^\d{4}-\d{2}-\d{2}$/.test(value)
+        ? value
+        : normalizeIsoDate(value, "source.publishedAt");
+      continue;
+    }
+    if (key === "browserClip") {
+      normalized.browserClip = browserClipProvenanceSchema.parse(value);
       continue;
     }
     if (URL_SOURCE_FIELDS.has(key)) {
+      if (typeof value !== "string") {
+        throw new Error(`source.${key} must be a string.`);
+      }
       try {
-        new URL(String(value));
+        new URL(value);
       } catch {
         throw new Error(`source.${key} must be a valid URL.`);
       }
     }
     if (CAPTURE_SOURCE_STRING_KEYS.has(key)) {
+      if (typeof value !== "string") {
+        throw new Error(`source.${key} must be a string.`);
+      }
       normalized[
         key as keyof Pick<
           CaptureSource,
@@ -295,9 +327,11 @@ function normalizeSource(
           | "mime"
           | "ext"
           | "author"
+          | "canonicalUrl"
+          | "site"
           | "externalId"
         >
-      ] = String(value);
+      ] = value;
     }
   }
 
@@ -489,6 +523,16 @@ export function extractCaptureSourceFromFrontmatter(
         .trim() as keyof CaptureSource;
       const nestedValue = nested.slice(nestedColon + 1).trim();
       if (nestedValue) {
+        if (nestedKey === "browserClip") {
+          try {
+            const parsed = JSON.parse(nestedValue) as unknown;
+            const provenance = browserClipProvenanceSchema.safeParse(parsed);
+            if (provenance.success) source.browserClip = provenance.data;
+          } catch {
+            // Ignore malformed optional browser provenance.
+          }
+          continue;
+        }
         source[nestedKey] = stripYamlString(nestedValue) as never;
       }
     }
@@ -664,6 +708,13 @@ export function planCapture(options: PlanCaptureOptions): CapturePlan {
     overwrite ? [] : existing
   );
   const overwritten = overwrite && existing.has(createPlan.relPath);
+  const clipIdentity = source.browserClip?.clipIdentity;
+  const provenanceConflict =
+    createPlan.openedExisting &&
+    clipIdentity !== undefined &&
+    options.existingProvenanceByRelPath?.get(createPlan.relPath) !==
+      clipIdentity;
+  const openedExisting = createPlan.openedExisting && !provenanceConflict;
 
   return {
     collection: options.input.collection,
@@ -675,16 +726,19 @@ export function planCapture(options: PlanCaptureOptions): CapturePlan {
     title,
     tags: contentTags,
     source,
-    openedExisting: createPlan.openedExisting,
+    openedExisting,
     createdWithSuffix: createPlan.createdWithSuffix,
+    provenanceConflict,
     collisionPolicy,
     collisionPolicyResult: overwritten
       ? "overwritten"
-      : createPlan.openedExisting
-        ? "opened_existing"
-        : createPlan.createdWithSuffix
-          ? "created_with_suffix"
-          : "created",
+      : provenanceConflict
+        ? "conflict"
+        : openedExisting
+          ? "opened_existing"
+          : createPlan.createdWithSuffix
+            ? "created_with_suffix"
+            : "created",
     overwrite,
   };
 }
@@ -705,7 +759,10 @@ export function buildCaptureReceipt(input: {
     collection: input.plan.collection,
     relPath: input.plan.relPath,
     absPath: input.absPath,
-    created: !input.plan.openedExisting && !overwritten,
+    created:
+      !input.plan.openedExisting &&
+      !input.plan.provenanceConflict &&
+      !overwritten,
     openedExisting: input.plan.openedExisting,
     createdWithSuffix: input.plan.createdWithSuffix,
     overwritten,

package/src/core/config-mutation.ts

@@ -13,15 +13,27 @@ import {
   normalizeConfigContentTypes,
   saveConfig,
 } from "../config";
+import { withWriteLock } from "./file-lock";
 
 export interface ConfigMutationContext {
   store: SqliteAdapter;
   configPath?: string;
   onConfigUpdated: (config: Config) => void;
+  /**
+   * Optional cross-process serialization boundary. The in-memory mutex remains
+   * authoritative within one process; callers sharing a config across
+   * processes must additionally share this OS-backed lock path.
+   */
+  writeLockPath?: string;
+  /**
+   * Runs after the selected config is durably present and before store projection.
+   * Setup recovery uses this boundary to persist a truthful resumable receipt.
+   */
+  afterConfigSaved?: (config: Config) => Promise<void> | void;
 }
 
 export type MutationResult<T = void> =
-  | { ok: true; config: Config; value?: T }
+  | { ok: true; config: Config; value?: T; skipSave?: boolean }
   | { ok: false; error: string; code: string };
 
 export type ApplyConfigResult<T = void> =
@@ -50,72 +62,90 @@ export async function applyConfigChange<T = void>(
   try {
     await previousMutex;
 
-    const loadResult = await loadConfig(ctx.configPath);
-    if (!loadResult.ok) {
-      return {
-        ok: false,
-        error: loadResult.error.message,
-        code: "LOAD_ERROR",
-      };
-    }
-    for (const warning of formatConfigWarnings(loadResult.warnings)) {
-      console.warn(warning);
-    }
-
-    const mutationResult = await mutate(loadResult.value);
-    if (!mutationResult.ok) {
-      return {
-        ok: false,
-        error: mutationResult.error,
-        code: mutationResult.code,
-      };
-    }
-
-    const normalized = normalizeConfigContentTypes(mutationResult.config);
-    for (const warning of formatConfigWarnings(normalized.warnings)) {
-      console.warn(warning);
-    }
-    const newConfig = normalized.config;
-    const saveResult = await saveConfig(newConfig, ctx.configPath);
-    if (!saveResult.ok) {
-      return {
-        ok: false,
-        error: saveResult.error.message,
-        code: "SAVE_ERROR",
-      };
-    }
-
-    const syncCollResult = await ctx.store.syncCollections(
-      newConfig.collections
-    );
-    if (!syncCollResult.ok) {
-      console.warn(
-        `Config saved but DB sync failed: ${syncCollResult.error.message}`
+    const applyFreshConfigChange = async (): Promise<ApplyConfigResult<T>> => {
+      const loadResult = await loadConfig(ctx.configPath);
+      if (!loadResult.ok) {
+        return {
+          ok: false,
+          error: loadResult.error.message,
+          code: "LOAD_ERROR",
+        };
+      }
+      for (const warning of formatConfigWarnings(loadResult.warnings)) {
+        console.warn(warning);
+      }
+
+      const mutationResult = await mutate(loadResult.value);
+      if (!mutationResult.ok) {
+        return {
+          ok: false,
+          error: mutationResult.error,
+          code: mutationResult.code,
+        };
+      }
+
+      const normalized = normalizeConfigContentTypes(mutationResult.config);
+      for (const warning of formatConfigWarnings(normalized.warnings)) {
+        console.warn(warning);
+      }
+      const newConfig = normalized.config;
+      if (!mutationResult.skipSave) {
+        const saveResult = await saveConfig(newConfig, ctx.configPath);
+        if (!saveResult.ok) {
+          return {
+            ok: false,
+            error: saveResult.error.message,
+            code: "SAVE_ERROR",
+          };
+        }
+      }
+
+      await ctx.afterConfigSaved?.(newConfig);
+
+      const syncCollResult = await ctx.store.syncCollections(
+        newConfig.collections
       );
-      return {
-        ok: false,
-        error: `DB sync failed: ${syncCollResult.error.message}`,
-        code: "SYNC_ERROR",
-      };
-    }
-
-    const syncCtxResult = await ctx.store.syncContexts(
-      newConfig.contexts ?? []
-    );
-    if (!syncCtxResult.ok) {
-      console.warn(
-        `Config saved but context sync failed: ${syncCtxResult.error.message}`
+      if (!syncCollResult.ok) {
+        console.warn(
+          `Config saved but DB sync failed: ${syncCollResult.error.message}`
+        );
+        return {
+          ok: false,
+          error: `DB sync failed: ${syncCollResult.error.message}`,
+          code: "SYNC_ERROR",
+        };
+      }
+
+      const syncCtxResult = await ctx.store.syncContexts(
+        newConfig.contexts ?? []
       );
-      return {
-        ok: false,
-        error: `Context sync failed: ${syncCtxResult.error.message}`,
-        code: "SYNC_ERROR",
-      };
+      if (!syncCtxResult.ok) {
+        console.warn(
+          `Config saved but context sync failed: ${syncCtxResult.error.message}`
+        );
+        return {
+          ok: false,
+          error: `Context sync failed: ${syncCtxResult.error.message}`,
+          code: "SYNC_ERROR",
+        };
+      }
+
+      ctx.onConfigUpdated(newConfig);
+
+      return { ok: true, config: newConfig, value: mutationResult.value };
+    };
+
+    if (!ctx.writeLockPath) {
+      return await applyFreshConfigChange();
+    }
+    try {
+      return await withWriteLock(ctx.writeLockPath, applyFreshConfigChange);
+    } catch (error) {
+      if (error instanceof Error && error.message.startsWith("LOCKED:")) {
+        return { ok: false, error: error.message, code: "LOCKED" };
+      }
+      throw error;
     }
-
-    ctx.onConfigUpdated(newConfig);
-
-    return { ok: true, config: newConfig, value: mutationResult.value };
   } finally {
     resolveMutex();
   }

package/src/core/file-lock.ts

@@ -4,8 +4,9 @@
  * @module src/core/file-lock
  */
 
-// node:fs/promises for mkdir/rm (no Bun equivalent for filesystem structure ops)
-import { mkdir, rm } from "node:fs/promises";
+import { Database } from "bun:sqlite";
+// node:fs/promises provides recursive directory creation without a Bun equivalent.
+import { mkdir } from "node:fs/promises";
 // node:path for dirname (no Bun path utils)
 import { dirname } from "node:path";
 
@@ -13,8 +14,8 @@ import { MCP_ERRORS } from "./errors";
 const DEFAULT_TIMEOUT_MS = 5000;
 const HOLD_SECONDS = 60 * 60 * 24 * 365;
 const READY_TOKEN = "READY";
-const DIRECTORY_LOCK_SUFFIX = ".dir";
-const DIRECTORY_LOCK_POLL_MS = 50;
+const SQLITE_LOCK_SUFFIX = ".sqlite";
+const MAX_BUSY_TIMEOUT_MS = 60_000;
 
 export interface WriteLockHandle {
   release: () => Promise<void>;
@@ -35,6 +36,7 @@ function resolveLockCommand(): LockCommand | null {
     return {
       path: lockfPath,
       args: (lockPath, timeoutSeconds, holdCommand) => [
+        "-k",
         "-t",
         String(timeoutSeconds),
         lockPath,
@@ -50,6 +52,7 @@ function resolveLockCommand(): LockCommand | null {
     return {
       path: flockPath,
       args: (lockPath, timeoutSeconds, holdCommand) => [
+        "--no-fork",
         "-w",
         String(timeoutSeconds),
         lockPath,
@@ -67,10 +70,6 @@ function buildHoldCommand(): string {
   return `printf '${READY_TOKEN}\\n'; exec sleep ${HOLD_SECONDS}`;
 }
 
-function delay(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
 async function waitForReady(
   proc: ReturnType<typeof Bun.spawn>
 ): Promise<boolean> {
@@ -96,33 +95,73 @@ async function waitForReady(
   }
 }
 
-async function acquireDirectoryLock(
+async function terminateLockProcess(
+  proc: ReturnType<typeof Bun.spawn>
+): Promise<void> {
+  if (process.platform === "win32") {
+    if (proc.exitCode === null) proc.kill();
+  } else {
+    try {
+      process.kill(-proc.pid, "SIGTERM");
+    } catch {
+      if (proc.exitCode === null) proc.kill();
+    }
+  }
+  await proc.exited.catch(() => undefined);
+}
+
+function sqliteLockPath(lockPath: string): string {
+  return `${lockPath}${SQLITE_LOCK_SUFFIX}`;
+}
+
+function normalizedBusyTimeout(timeoutMs: number): number {
+  if (!Number.isFinite(timeoutMs)) {
+    return DEFAULT_TIMEOUT_MS;
+  }
+  return Math.min(Math.max(0, Math.floor(timeoutMs)), MAX_BUSY_TIMEOUT_MS);
+}
+
+function isSqliteLockContention(cause: unknown): boolean {
+  if (cause === null || typeof cause !== "object") {
+    return false;
+  }
+  const code = "code" in cause ? cause.code : undefined;
+  return code === "SQLITE_BUSY" || code === "SQLITE_LOCKED";
+}
+
+export async function acquireSqliteWriteLock(
   lockPath: string,
   timeoutMs: number
 ): Promise<WriteLockHandle | null> {
-  const directoryLockPath = `${lockPath}${DIRECTORY_LOCK_SUFFIX}`;
-  await mkdir(dirname(directoryLockPath), { recursive: true });
+  const databasePath = sqliteLockPath(lockPath);
+  await mkdir(dirname(databasePath), { recursive: true });
 
-  const deadline = Date.now() + Math.max(0, timeoutMs);
-  while (true) {
-    try {
-      await mkdir(directoryLockPath);
-      return {
-        release: async () => {
-          await rm(directoryLockPath, { force: true, recursive: true });
-        },
-      };
-    } catch (error) {
-      const code = (error as { code?: string }).code;
-      if (code !== "EEXIST") {
-        throw error;
-      }
-      if (Date.now() >= deadline) {
-        return null;
-      }
-      await delay(Math.min(DIRECTORY_LOCK_POLL_MS, deadline - Date.now()));
+  const database = new Database(databasePath, { create: true });
+  try {
+    database.exec(`PRAGMA busy_timeout = ${normalizedBusyTimeout(timeoutMs)}`);
+    database.exec("BEGIN IMMEDIATE");
+  } catch (cause) {
+    database.close();
+    if (isSqliteLockContention(cause)) {
+      return null;
     }
+    throw cause;
   }
+
+  let released = false;
+  return {
+    release: async () => {
+      if (released) {
+        return;
+      }
+      released = true;
+      try {
+        database.exec("ROLLBACK");
+      } finally {
+        database.close();
+      }
+    },
+  };
 }
 
 export async function acquireWriteLock(
@@ -131,7 +170,7 @@ export async function acquireWriteLock(
 ): Promise<WriteLockHandle | null> {
   const cmd = resolveLockCommand();
   if (!cmd) {
-    return acquireDirectoryLock(lockPath, timeoutMs);
+    return acquireSqliteWriteLock(lockPath, timeoutMs);
   }
 
   await mkdir(dirname(lockPath), { recursive: true });
@@ -141,6 +180,7 @@ export async function acquireWriteLock(
   const proc = Bun.spawn(
     [cmd.path, ...cmd.args(lockPath, timeoutSeconds, holdCommand)],
     {
+      detached: true,
       stdout: "pipe",
       stderr: "pipe",
     }
@@ -148,19 +188,32 @@ export async function acquireWriteLock(
 
   const ready = await waitForReady(proc);
   if (!ready) {
-    proc.kill();
-    await proc.exited.catch(() => undefined);
+    await terminateLockProcess(proc);
     return null;
   }
 
   return {
-    release: async () => {
-      proc.kill();
-      await proc.exited.catch(() => undefined);
-    },
+    release: () => terminateLockProcess(proc),
   };
 }
 
+export async function withSqliteWriteLock<T>(
+  lockPath: string,
+  fn: () => Promise<T>,
+  timeoutMs: number = DEFAULT_TIMEOUT_MS
+): Promise<T> {
+  const lock = await acquireSqliteWriteLock(lockPath, timeoutMs);
+  if (!lock) {
+    throw new Error(`${MCP_ERRORS.LOCKED.code}: ${MCP_ERRORS.LOCKED.message}`);
+  }
+
+  try {
+    return await fn();
+  } finally {
+    await lock.release();
+  }
+}
+
 export async function withWriteLock<T>(
   lockPath: string,
   fn: () => Promise<T>,