@gmickel/gno 2.4.0 → 2.6.0

package/src/serve/capture-service.ts

@@ -12,7 +12,13 @@ import { basename, dirname, join as pathJoin } from "node:path";
 
 import type { Collection, Config } from "../config/types";
 import type { PreparedBrowserClip } from "../core/browser-clip";
-import type { CaptureInput, CapturePlan, CaptureSource } from "../core/capture";
+import type {
+  CaptureInput,
+  CapturePlan,
+  CaptureReceipt,
+  CaptureSource,
+  SyncCapturedFileResult,
+} from "../core/capture";
 import type { JobManager } from "../core/job-manager";
 import type { SqliteAdapter } from "../store/sqlite/adapter";
 import type { ClipperIdempotencyPlan } from "../store/sqlite/clipper-store-types";
@@ -30,12 +36,13 @@ import {
   hashCaptureContent,
   listCaptureDiskRelPaths,
   planCapture,
-  syncCapturedFile,
 } from "../core/capture";
+import { publishCapture } from "../core/capture-publish";
 import { writeCapturePlanFile } from "../core/capture-write";
 import { MCP_ERRORS } from "../core/errors";
 import { withWriteLock } from "../core/file-lock";
 import { recordContentMutation } from "../core/mutation-generations";
+import { localRequestLedger } from "../core/request-receipts";
 import { DEFAULT_LOCK_WAIT_MS, writeLeasePath } from "../core/write-lease";
 import {
   type CollectionSyncResult,
@@ -331,6 +338,37 @@ const executeCaptureAsJob = async (
   };
 };
 
+/** Shared leased publication wired to the resident watch/event hooks. */
+const residentPublication = (
+  context: ResidentCaptureContext,
+  store: SqliteAdapter,
+  collection: Collection,
+  dependencies: ResidentCaptureDependencies
+) => ({
+  collection,
+  store,
+  lockPath: resolveCaptureLockPath(context, dependencies),
+  lockWaitMs: dependencies.lockWaitMs ?? DEFAULT_LOCK_WAIT_MS,
+  config: context.config,
+  syncPaths: dependencies.syncPaths,
+  beforeWrite: (absPath: string) => context.watchService?.suppress(absPath),
+  afterSync: (synced: SyncCapturedFileResult, receipt: CaptureReceipt) => {
+    if (synced.result) {
+      recordContentMutation(synced.result, context.markContentMutation);
+    }
+    if (!receipt.openedExisting) {
+      emitCaptureCreated(context, collection, receipt.relPath);
+    }
+  },
+});
+
+const residentCaptureStatus = (receipt: CaptureReceipt): number =>
+  receipt.collisionPolicyResult === "conflict"
+    ? HTTP_CONFLICT
+    : receipt.openedExisting
+      ? HTTP_OK
+      : HTTP_CREATED;
+
 /**
  * Write + lexical sync under the shared write lease; the response is sent
  * only once the capture is retrievable. Throws `CaptureSyncError` when the
@@ -343,37 +381,65 @@ const executeCaptureAwaitingSync = async (
   planned: Extract<ResidentCapturePlanResult, { ok: true }>,
   dependencies: ResidentCaptureDependencies
 ): Promise<{ body: unknown; status: number }> => {
-  const { collection, fullPath, plan } = planned;
-  return withWriteLock(
-    resolveCaptureLockPath(context, dependencies),
-    async () => {
-      await mkdir(dirname(fullPath), { recursive: true });
-      context.watchService?.suppress(fullPath);
-      await writeCapturePlanFile(plan, fullPath);
-      const synced = await syncCapturedFile({
-        collection,
-        store,
-        relPath: plan.relPath,
-        absPath: fullPath,
-        config: context.config,
-        syncPaths: dependencies.syncPaths,
-      });
-      if (synced.result) {
-        recordContentMutation(synced.result, context.markContentMutation);
-      }
-      emitCaptureCreated(context, collection, plan.relPath);
-      return {
-        body: buildCaptureReceipt({
-          plan,
-          absPath: fullPath,
-          docid: synced.docid,
-          sync: synced.sync,
-        }),
-        status: HTTP_CREATED,
-      };
-    },
-    dependencies.lockWaitMs ?? DEFAULT_LOCK_WAIT_MS
+  const { receipt } = await publishCapture({
+    ...residentPublication(context, store, planned.collection, dependencies),
+    plan: async () => planned.plan,
+  });
+  return { body: receipt, status: HTTP_CREATED };
+};
+
+/** A resident plan rejection, carried through the leased planner. */
+export class ResidentCapturePlanError extends Error {
+  readonly shape: Extract<ResidentCapturePlanResult, { ok: false }>;
+
+  constructor(shape: Extract<ResidentCapturePlanResult, { ok: false }>) {
+    super(shape.message);
+    this.name = "ResidentCapturePlanError";
+    this.shape = shape;
+  }
+}
+
+/**
+ * `/api/capture` with a request ID: planning moves under the lease and the
+ * request-receipt service replays, finishes, or admits the capture.
+ */
+export const executeRequestedResidentCapture = async (
+  context: ResidentCaptureContext,
+  store: SqliteAdapter,
+  input: CaptureInput,
+  requestId: string,
+  dependencies: ResidentCaptureDependencies = {}
+): Promise<{ body: unknown; status: number }> => {
+  const collection = context.config.collections.find(
+    (candidate) =>
+      candidate.name.toLowerCase() === input.collection.toLowerCase()
   );
+  if (!collection) {
+    throw new ResidentCapturePlanError({
+      ok: false,
+      code: "NOT_FOUND",
+      message: `Collection not found: ${input.collection}`,
+      status: 404,
+    });
+  }
+  const normalized = { ...input, collection: collection.name };
+  const published = await publishCapture({
+    ...residentPublication(context, store, collection, dependencies),
+    plan: async () => {
+      const planned = await planResidentCapture(context, store, normalized);
+      if (!planned.ok) throw new ResidentCapturePlanError(planned);
+      return planned.plan;
+    },
+    request: {
+      ...localRequestLedger(store.getDbPath()),
+      requestId,
+      input: normalized,
+    },
+  });
+  return {
+    body: { ...published.receipt, request: published.request },
+    status: residentCaptureStatus(published.receipt),
+  };
 };
 
 /**

package/src/serve/compiled-context.ts

@@ -0,0 +1,84 @@
+import type { ServerContext } from "./context";
+
+/** Read-only compiled context adapters; caller authority comes from the socket. */
+import {
+  previewCompiledContext,
+  checkCompiledContext,
+} from "../app/compiled-context";
+import {
+  compiledContextPreviewInputSchema,
+  compiledContextCheckInputSchema,
+} from "../core/compiled-context";
+import {
+  isLocalClientRequest,
+  type RequestPeerServer,
+} from "./request-locality";
+
+export async function handleCompiledContext(
+  context: ServerContext,
+  request: Request,
+  server: RequestPeerServer | undefined,
+  operation: "preview" | "check"
+): Promise<Response> {
+  try {
+    // Bound bytes before JSON parsing, even when Content-Length is absent.
+    const reader = request.body?.getReader();
+    if (!reader)
+      return Response.json(
+        { error: { code: "invalid_input", message: "JSON body required" } },
+        { status: 400 }
+      );
+    const chunks: Uint8Array[] = [];
+    let size = 0;
+    while (true) {
+      const part = await reader.read();
+      if (part.done) break;
+      size += part.value.byteLength;
+      if (size > 8 * 1024 * 1024 + 65536) {
+        await reader.cancel();
+        return Response.json(
+          {
+            error: {
+              code: "invalid_input",
+              message: "Compiled context request exceeds byte limit",
+            },
+          },
+          { status: 413 }
+        );
+      }
+      chunks.push(part.value);
+    }
+    const raw: unknown = JSON.parse(
+      await new Blob(chunks.map((chunk) => new Uint8Array(chunk))).text()
+    );
+    const input =
+      operation === "preview"
+        ? compiledContextPreviewInputSchema.parse(raw)
+        : compiledContextCheckInputSchema.parse(raw);
+    const local = isLocalClientRequest(request, server);
+    const deps = {
+      store: context.store,
+      config: context.config,
+      indexName: context.indexName,
+      destinationZone: local ? ("local_process" as const) : ("remote" as const),
+      caller: { authenticated: local, operationAuthorized: true },
+    };
+    const result =
+      operation === "preview"
+        ? await previewCompiledContext(input, deps)
+        : await checkCompiledContext(input, deps);
+    return Response.json(result);
+  } catch {
+    // Supplied Capsules may contain private metadata; errors never echo inputs.
+    return Response.json(
+      {
+        error: {
+          code: "compiled_context_unavailable",
+          message:
+            "Compiled context is invalid, stale, or unavailable for this caller",
+        },
+      },
+      { status: 400 }
+    );
+  }
+}

package/src/serve/config-sync.ts

@@ -16,6 +16,7 @@ import {
   type MutationResult,
 } from "../core/config-mutation";
 import { withContentTypeRules } from "../ingestion";
+import { watchedCollections } from "../sessions/config";
 
 /**
  * Apply a config mutation atomically with serialization.
@@ -56,7 +57,7 @@ export async function applyConfigChange(
 
   if (result.ok) {
     ctxHolder.watchService?.updateCollections(
-      ctxHolder.config.collections,
+      watchedCollections(ctxHolder.config),
       withContentTypeRules({}, ctxHolder.config)
     );
   }
@@ -86,7 +87,7 @@ export async function applyConfigChangeTyped<T>(
 
   if (result.ok) {
     ctxHolder.watchService?.updateCollections(
-      ctxHolder.config.collections,
+      watchedCollections(ctxHolder.config),
       withContentTypeRules({}, ctxHolder.config)
     );
   }

package/src/serve/public/app.tsx

@@ -47,7 +47,9 @@ const Collections = lazy(() => import("./pages/Collections"));
 const Connectors = lazy(() => import("./pages/Connectors"));
 const Ask = lazy(() => import("./pages/Ask"));
 const GraphView = lazy(() => import("./pages/GraphView"));
+const CompiledContext = lazy(() => import("./pages/CompiledContext"));
 const TraceHistory = lazy(() => import("./pages/TraceHistory"));
+const Sessions = lazy(() => import("./pages/Sessions"));
 
 type Route =
   | "/"
@@ -59,7 +61,9 @@ type Route =
   | "/collections"
   | "/graph"
   | "/connectors"
-  | "/traces";
+  | "/context/compiled"
+  | "/traces"
+  | "/sessions";
 type Navigate = (to: string | number) => void;
 
 interface RoutePageProps {
@@ -78,6 +82,8 @@ const routes: Record<Route, React.ComponentType<RoutePageProps>> = {
   "/ask": Ask,
   "/graph": GraphView,
   "/traces": TraceHistory,
+  "/sessions": Sessions,
+  "/context/compiled": CompiledContext,
 };
 
 interface AppContentProps {
@@ -196,6 +202,14 @@ function AppContent({
               Trace history
             </button>
             <span className="text-border/30">—</span>
+            <button
+              className="transition-colors duration-300 hover:text-primary"
+              onClick={() => navigate("/context/compiled")}
+              type="button"
+            >
+              Compiled context
+            </button>
+            <span className="text-border/30">—</span>
             <a
               className="transition-colors duration-300 hover:text-primary"
               href="https://github.com/gmickel/gno"

package/src/serve/public/components/CaptureModal.tsx

@@ -26,6 +26,13 @@ import {
   resolveNotePreset,
 } from "../../../core/note-presets";
 import { apiFetch } from "../hooks/use-api";
+import {
+  clearRequestIntent,
+  type RequestIntent,
+  requestIdForIntent,
+} from "../lib/request-intent";
+
+const CAPTURE_INTENT_KEY = "gno:capture-intent";
 import { getActiveWikiLinkQuery } from "../lib/wiki-link";
 import { IndexingProgress } from "./IndexingProgress";
 import { TagInput } from "./TagInput";
@@ -169,6 +176,7 @@ export function CaptureModal({
   const [wikiLinkPosition, setWikiLinkPosition] = useState({ x: 24, y: 24 });
   const [wikiLinkActiveIndex, setWikiLinkActiveIndex] = useState(-1);
   const contentRef = useRef<HTMLTextAreaElement | null>(null);
+  const captureIntentRef = useRef<RequestIntent | null>(null);
 
   // Submission state
   const [state, setState] = useState<ModalState>("form");
@@ -311,19 +319,28 @@ export function CaptureModal({
         ? selectedPresetId
         : undefined;
 
+    const payload = {
+      collection,
+      title,
+      folderPath: defaultFolderPath || undefined,
+      content: presetOnly ? undefined : content,
+      presetId: submitPresetId,
+      collisionPolicy: "create_with_suffix",
+      source,
+      ...(tags.length > 0 && { tags }),
+    };
     const { data, error: err } = await apiFetch<CaptureResponse>(
       "/api/capture",
       {
         method: "POST",
         body: JSON.stringify({
-          collection,
-          title,
-          folderPath: defaultFolderPath || undefined,
-          content: presetOnly ? undefined : content,
-          presetId: submitPresetId,
-          collisionPolicy: "create_with_suffix",
-          source,
-          ...(tags.length > 0 && { tags }),
+          ...payload,
+          // A retry of this exact capture replays instead of adding a suffix copy.
+          requestId: requestIdForIntent(
+            captureIntentRef,
+            JSON.stringify(payload),
+            CAPTURE_INTENT_KEY
+          ),
         }),
       }
     );
@@ -335,6 +352,7 @@ export function CaptureModal({
     }
 
     if (data) {
+      clearRequestIntent(captureIntentRef, CAPTURE_INTENT_KEY);
       // Save last used collection
       localStorage.setItem(STORAGE_KEY, collection);