@gmickel/gno 1.28.0 → 1.29.1

package/src/serve/public/pages/Collections.tsx

@@ -91,6 +91,7 @@ interface CollectionStats {
     "override" | "preset" | "default"
   >;
   pattern?: string;
+  egressPolicy?: CollectionModelDetails["egressPolicy"];
 }
 
 interface StatusResponse {
@@ -411,6 +412,7 @@ export default function Collections({ navigate }: PageProps) {
         models: config?.models,
         modelSources: config?.modelSources,
         pattern: config?.pattern,
+        egressPolicy: config?.egressPolicy,
       };
     });
 
@@ -722,6 +724,7 @@ export default function Collections({ navigate }: PageProps) {
       />
 
       <CollectionModelDialog
+        availableCollections={collections.map(({ name }) => name)}
         collection={modelDialogCollection}
         onOpenChange={(open) => {
           if (!open) {

package/src/serve/resident-request.ts

@@ -18,6 +18,69 @@ function saturatedResponse(): Response {
   );
 }
 
+function policyChangedResponse(): Response {
+  return Response.json(
+    {
+      error: {
+        code: "EGRESS_POLICY_CHANGED",
+        message: "Collection policy changed; retry",
+      },
+    },
+    { status: 409 }
+  );
+}
+
+function wrapResidentStream(
+  response: Response,
+  isCurrent: () => boolean,
+  finish: () => void
+): Response {
+  if (!response.body) {
+    finish();
+    return response;
+  }
+  const reader = response.body.getReader();
+  let finished = false;
+  const finishOnce = (): void => {
+    if (finished) return;
+    finished = true;
+    finish();
+  };
+  const body = new ReadableStream<Uint8Array>({
+    async pull(controller) {
+      try {
+        if (!isCurrent()) {
+          await reader.cancel("EGRESS_POLICY_CHANGED");
+          controller.close();
+          finishOnce();
+          return;
+        }
+        const result = await reader.read();
+        if (!isCurrent()) {
+          await reader.cancel("EGRESS_POLICY_CHANGED");
+          controller.close();
+          finishOnce();
+          return;
+        }
+        if (result.done) {
+          controller.close();
+          finishOnce();
+          return;
+        }
+        controller.enqueue(result.value);
+      } catch (error) {
+        controller.error(error);
+        finishOnce();
+      }
+    },
+    async cancel(reason) {
+      finishOnce();
+      await reader.cancel(reason);
+    },
+  });
+  return new Response(body, response);
+}
+
 export async function handleResidentRead(
   runtime: ResidentRuntime,
   request: Request | undefined,
@@ -27,13 +90,28 @@ export async function handleResidentRead(
   if (!admitted) return unavailableResponse();
 
   let releaseReader: (() => void) | undefined;
+  let deferredFinish = false;
+  const isAuthorizationEpochCurrent = (): boolean =>
+    admitted.isAuthorizationEpochCurrent?.() ?? true;
+  const finish = (): void => {
+    releaseReader?.();
+    admitted.finish();
+  };
   try {
     releaseReader = await runtime.readerGate.acquire(admitted.signal);
     if (admitted.signal.aborted) return unavailableResponse();
     const response = await runtime.withModelLease(() =>
       Promise.resolve(operation(admitted.signal))
     );
-    return admitted.signal.aborted ? unavailableResponse() : response;
+    if (admitted.signal.aborted) return unavailableResponse();
+    if (!isAuthorizationEpochCurrent()) {
+      return policyChangedResponse();
+    }
+    if (response.headers.get("content-type")?.includes("text/event-stream")) {
+      deferredFinish = true;
+      return wrapResidentStream(response, isAuthorizationEpochCurrent, finish);
+    }
+    return response;
   } catch (error) {
     if (
       admitted.signal.aborted ||
@@ -49,7 +127,6 @@ export async function handleResidentRead(
     }
     throw error;
   } finally {
-    releaseReader?.();
-    admitted.finish();
+    if (!deferredFinish) finish();
   }
 }

package/src/serve/resident-runtime.ts

@@ -32,6 +32,8 @@ import {
   loadConfig,
 } from "../config";
 import { SavedCapsuleReverificationScheduler } from "../core/capsule-reverification-scheduler";
+import { collectionEgressPolicyEpoch } from "../core/collection-egress-policy-service";
+import { authorizeCurrentEgress } from "../core/egress-authorization";
 import { acquireWriteLock } from "../core/file-lock";
 import { JobManager } from "../core/job-manager";
 import { recordContentMutation } from "../core/mutation-generations";
@@ -78,8 +80,10 @@ export interface ResidentGeneration {
 }
 
 export interface ResidentRequestHandle {
+  authorizationEpoch?: string;
   id: string;
   signal: AbortSignal;
+  isAuthorizationEpochCurrent?(): boolean;
   finish(): void;
 }
 
@@ -101,12 +105,14 @@ export interface ResidentRuntime {
   readonly generations: ResidentGeneration;
   readonly activeRequests: number;
   readonly activeSessions: number;
+  readonly authorizationEpoch: string;
   readonly isShuttingDown: boolean;
   getStatus(): ResidentStatus;
   setListenerPort(port: number | null): void;
   setTransportStatusProvider(
     provider: (() => HttpMcpTransportStatus) | null
   ): void;
+  setPolicySessionInvalidator(invalidator: (() => Promise<void>) | null): void;
   admitRequest(signal?: AbortSignal): ResidentRequestHandle | null;
   withModelLease<T>(operation: () => Promise<T>): Promise<T>;
   markContentMutation(): void;
@@ -306,6 +312,8 @@ export async function startResidentRuntime(
     serverInstanceId,
     toolMutex,
   });
+  let authorizationEpoch = collectionEgressPolicyEpoch(initialConfig);
+  jobManager.setAuthorizationEpoch(authorizationEpoch);
   ctxHolder.jobManager = jobManager;
   const admission = new AdmissionController();
   const readerGate = new ReaderGate(
@@ -315,6 +323,7 @@ export async function startResidentRuntime(
   const startedAt = Date.now();
   let listenerPort: number | null = null;
   let transportStatusProvider: (() => HttpMcpTransportStatus) | null = null;
+  let policySessionInvalidator: (() => Promise<void>) | null = null;
   let shutdownState: ResidentStatus["shutdown"]["state"] = "none";
   let admissionState: ResidentStatus["admission"]["state"] = "accepting";
   let disposed = false;
@@ -359,7 +368,32 @@ export async function startResidentRuntime(
     markIndexMutation: () => {
       generations.index += 1;
     },
+    invalidateEgressPolicy: async () =>
+      (await ctxHolder.invalidateEgressPolicy?.()) ?? {
+        policyEpoch: collectionEgressPolicyEpoch(ctxHolder.config),
+        queuedJobsInvalidated: 0,
+        sessionsInvalidated: 0,
+        staleWorkMustRetry: true,
+      },
   });
+  mcpContext.authorizeTraceExport = async (lineage) => {
+    const egress = mcpContext.getEgressContext?.();
+    return authorizeCurrentEgress({
+      store,
+      config: ctxHolder.config,
+      lineage,
+      action: "export",
+      destinationZone:
+        egress?.destinationZone === "loopback"
+          ? "local_process"
+          : (egress?.destinationZone ?? "local_process"),
+      caller: egress?.caller ?? {
+        authenticated: true,
+        operationAuthorized: true,
+      },
+      contentClass: "retrieval_trace",
+    });
+  };
 
   const runtime: ResidentRuntime = {
     mode: options.mode ?? "serve",
@@ -385,10 +419,22 @@ export async function startResidentRuntime(
     get activeSessions() {
       return transportStatusProvider?.().activeSessions ?? 0;
     },
+    get authorizationEpoch() {
+      return authorizationEpoch;
+    },
     get isShuttingDown() {
       return disposed || !admission.accepting;
     },
-    admitRequest: (signal) => admission.admit(signal),
+    admitRequest: (signal) => {
+      const admitted = admission.admit(signal);
+      if (!admitted) return null;
+      const requestEpoch = authorizationEpoch;
+      return {
+        ...admitted,
+        authorizationEpoch: requestEpoch,
+        isAuthorizationEpochCurrent: () => requestEpoch === authorizationEpoch,
+      };
+    },
     async withModelLease<T>(operation: () => Promise<T>): Promise<T> {
       const lease = modelManager.acquireLease();
       try {
@@ -450,6 +496,9 @@ export async function startResidentRuntime(
     setTransportStatusProvider(provider) {
       transportStatusProvider = provider;
     },
+    setPolicySessionInvalidator(invalidator) {
+      policySessionInvalidator = invalidator;
+    },
     async syncAll(syncOptions = {}) {
       const config = ctxHolder.config;
       const syncAllService = deps.syncAllService
@@ -508,6 +557,19 @@ export async function startResidentRuntime(
   };
   ctxHolder.startBackgroundWork = (operation) =>
     runtime.startBackgroundWork(operation);
+  ctxHolder.invalidateEgressPolicy = async () => {
+    const sessionsInvalidated = transportStatusProvider?.().activeSessions ?? 0;
+    const policyEpoch = collectionEgressPolicyEpoch(ctxHolder.config);
+    authorizationEpoch = policyEpoch;
+    const queuedJobsInvalidated = jobManager.setAuthorizationEpoch(policyEpoch);
+    await policySessionInvalidator?.();
+    return {
+      policyEpoch,
+      queuedJobsInvalidated,
+      sessionsInvalidated,
+      staleWorkMustRetry: true,
+    };
+  };
   mcpContext.getResidentStatus = () => runtime.getStatus();
   return { success: true, runtime };
 }

package/src/serve/routes/api.ts

@@ -14,6 +14,7 @@ import type {
   Collection,
   CollectionModelOverrides,
   Config,
+  EgressPolicy,
   ModelPreset,
 } from "../../config/types";
 import type { JobManager } from "../../core/job-manager";
@@ -49,6 +50,13 @@ import {
   normalizeContentTypes,
 } from "../../config";
 import { type PublicCaptureInput } from "../../core/capture";
+import { projectCollectionEgressPolicy } from "../../core/collection-egress-policy-projection";
+import {
+  CollectionEgressPolicyService,
+  type CollectionEgressPolicyState,
+  type EgressRelaxationConfirmation,
+} from "../../core/collection-egress-policy-service";
+import { parsePolicySetBody } from "../../core/collection-egress-policy-validation";
 import {
   type ConnectorVerificationCode,
   getConnectorVerificationRemediation,
@@ -58,6 +66,7 @@ import {
   deriveEditableCopyRelPath,
   getDocumentCapabilities,
 } from "../../core/document-capabilities";
+import { EgressAuditService } from "../../core/egress-audit";
 import {
   atomicWrite,
   copyFilePath,
@@ -144,6 +153,7 @@ import {
   executeResidentCapturePlan,
   planResidentCapture,
 } from "../capture-service";
+import { parseClosedJson } from "../closed-json";
 import { applyConfigChange, applyConfigChangeTyped } from "../config-sync";
 import {
   getConnectorStatuses,
@@ -176,6 +186,12 @@ export interface ContextHolder {
   jobManager?: JobManager;
   markContentMutation?: () => void;
   markIndexMutation?: () => void;
+  invalidateEgressPolicy?: () => Promise<{
+    policyEpoch: string;
+    queuedJobsInvalidated: number;
+    sessionsInvalidated: number;
+    staleWorkMustRetry: true;
+  }>;
   startBackgroundWork?: (
     operation: (signal: AbortSignal) => Promise<void>
   ) => boolean;
@@ -361,6 +377,11 @@ export interface UpdateCollectionRequestBody {
   };
 }
 
+export interface UpdateCollectionEgressPolicyRequestBody {
+  policy: EgressPolicy;
+  confirmation?: EgressRelaxationConfirmation;
+}
+
 export interface ClearCollectionEmbeddingsRequestBody {
   mode?: "stale" | "all";
 }
@@ -387,6 +408,7 @@ export interface CollectionResponse {
     gen: "override" | "preset" | "default";
   };
   activePresetId: string;
+  egressPolicy: CollectionEgressPolicyState | null;
 }
 
 function serializeCollection(
@@ -406,6 +428,12 @@ function serializeCollection(
     effectiveModels: getCollectionEffectiveModels(config, collection.name),
     modelSources: getCollectionModelSources(config, collection.name),
     activePresetId: modelConfig.activePreset,
+    egressPolicy: (() => {
+      const result = new CollectionEgressPolicyService({
+        getConfig: () => config,
+      }).get(collection.name);
+      return result.ok ? result.value : null;
+    })(),
   };
 }
 
@@ -1001,6 +1029,150 @@ export async function handleCollections(config: Config): Promise<Response> {
   );
 }
 
+const collectionPolicyService = (
+  ctxHolder: ContextHolder,
+  store: SqliteAdapter,
+  collection: string
+): CollectionEgressPolicyService =>
+  new CollectionEgressPolicyService({
+    getConfig: () => ctxHolder.config,
+    mutateConfig: (mutate) =>
+      applyConfigChangeTyped(
+        ctxHolder,
+        store,
+        (config) => mutate(config),
+        undefined,
+        {
+          projectStore: (targetStore, config) =>
+            projectCollectionEgressPolicy(targetStore, config, collection),
+        }
+      ),
+    onPolicyChanged: async () =>
+      (await ctxHolder.invalidateEgressPolicy?.()) ?? {
+        policyEpoch: "egress-epoch-standalone",
+        queuedJobsInvalidated: 0,
+        sessionsInvalidated: 0,
+        staleWorkMustRetry: true,
+      },
+  });
+
+export function handleCollectionEgressPolicy(
+  ctxHolder: ContextHolder,
+  name: string
+): Response {
+  const state = new CollectionEgressPolicyService({
+    getConfig: () => ctxHolder.config,
+  }).get(name);
+  if (state.ok) return jsonResponse(state.value);
+  return errorResponse(
+    state.code === "NOT_FOUND" ? "NOT_FOUND" : "VALIDATION",
+    state.error,
+    state.code === "NOT_FOUND" ? 404 : 400
+  );
+}
+
+export async function handleUpdateCollectionEgressPolicy(
+  ctxHolder: ContextHolder,
+  store: SqliteAdapter,
+  name: string,
+  req: Request
+): Promise<Response> {
+  const parsed = await parseClosedJson(req);
+  if (!parsed.ok) return errorResponse("VALIDATION", parsed.error, 400);
+  const input = parsePolicySetBody(parsed.value, name);
+  if (!input.ok) return errorResponse("VALIDATION", input.error, 400);
+  const result = await collectionPolicyService(ctxHolder, store, name).set(
+    input.value
+  );
+  if (!result.ok) {
+    const status =
+      result.code === "NOT_FOUND"
+        ? 404
+        : result.code === "EGRESS_RELAXATION_CONFIRMATION_REQUIRED"
+          ? 409
+          : 400;
+    return errorResponse(result.code, result.error, status);
+  }
+  return jsonResponse(result.value);
+}
+
+export async function handleCollectionEgressCheck(
+  ctxHolder: ContextHolder,
+  req: Request
+): Promise<Response> {
+  const parsed = await parseClosedJson(req);
+  if (!parsed.ok) return errorResponse("VALIDATION", parsed.error, 400);
+  const result = new CollectionEgressPolicyService({
+    getConfig: () => ctxHolder.config,
+  }).check(parsed.value);
+  return result.ok
+    ? jsonResponse(result.value)
+    : errorResponse("VALIDATION", result.error, 400);
+}
+
+export async function handleEgressAuditList(
+  store: SqliteAdapter,
+  req: Request
+): Promise<Response> {
+  const url = new URL(req.url);
+  const limit = url.searchParams.has("limit")
+    ? Number(url.searchParams.get("limit"))
+    : undefined;
+  const result = await new EgressAuditService(store).list({
+    limit,
+    cursor: url.searchParams.get("cursor") ?? undefined,
+  });
+  return result.ok
+    ? jsonResponse(result.value)
+    : errorResponse(result.error.code, result.error.message);
+}
+
+export async function handleEgressAuditShow(
+  store: SqliteAdapter,
+  auditId: string
+): Promise<Response> {
+  const result = await new EgressAuditService(store).show(auditId);
+  return result.ok
+    ? jsonResponse(result.value)
+    : errorResponse(
+        result.error.code,
+        result.error.message,
+        result.error.code === "NOT_FOUND" ? 404 : 400
+      );
+}
+
+export async function handleEgressAuditStatus(
+  store: SqliteAdapter
+): Promise<Response> {
+  const result = await new EgressAuditService(store).status();
+  return result.ok
+    ? jsonResponse(result.value)
+    : errorResponse(result.error.code, result.error.message);
+}
+
+export async function handleEgressAuditDelete(
+  store: SqliteAdapter,
+  auditId: string
+): Promise<Response> {
+  const result = await new EgressAuditService(store).delete(auditId);
+  return result.ok
+    ? jsonResponse(result.value)
+    : errorResponse(
+        result.error.code,
+        result.error.message,
+        result.error.code === "NOT_FOUND" ? 404 : 400
+      );
+}
+
+export async function handleEgressAuditPurge(
+  store: SqliteAdapter
+): Promise<Response> {
+  const result = await new EgressAuditService(store).purge();
+  return result.ok
+    ? jsonResponse(result.value)
+    : errorResponse(result.error.code, result.error.message);
+}
+
 /**
  * POST /api/publish/export
  * Build a gno.sh-compatible publish artifact for a collection or single doc.
@@ -1166,6 +1338,7 @@ export async function handleCreateCollection(
   if (!collection) {
     return errorResponse("RUNTIME", "Collection not found after add", 500);
   }
+  await ctxHolder.invalidateEgressPolicy?.();
   const jobResult = await startJob(
     "add",
     async (): Promise<SyncResult> => {
@@ -1281,6 +1454,7 @@ export async function handleDeleteCollection(
     const status = statusMap[syncResult.code] ?? 500;
     return errorResponse(syncResult.code, syncResult.error, status);
   }
+  await ctxHolder.invalidateEgressPolicy?.();
   ctxHolder.markContentMutation?.();
   ctxHolder.markIndexMutation?.();
   return jsonResponse({

package/src/serve/routes/clipper.ts

@@ -1,10 +1,16 @@
 /** Dedicated loopback browser-clipper HTTP gateway. */
 
+import type { EgressLineage } from "../../core/egress-provenance";
 import type { HttpMcpPeerServer } from "../../mcp/http-security";
 import type { SqliteAdapter } from "../../store/sqlite/adapter";
 import type { ContextHolder } from "./api";
 
 import { prepareBrowserClip } from "../../core/browser-clip";
+import {
+  enforceCollectionEgressWithAudit,
+  EGRESS_DENIED_MESSAGE,
+  EgressDeniedError,
+} from "../../core/egress-enforcement";
 import {
   planResidentCapture,
   type ResidentCapturePlanResult,
@@ -83,6 +89,40 @@ const pollStatusCode = (result: ClipperPairPollResult): number => {
   return 200;
 };
 
+const enforceClipWrite = async (
+  ctxHolder: ContextHolder,
+  store: SqliteAdapter,
+  body: unknown
+): Promise<EgressLineage | undefined> => {
+  const record =
+    typeof body === "object" && body !== null
+      ? (body as Record<string, unknown>)
+      : null;
+  const payload =
+    typeof record?.payload === "object" && record.payload !== null
+      ? (record.payload as Record<string, unknown>)
+      : record;
+  const destination =
+    typeof payload?.destination === "object" && payload.destination !== null
+      ? (payload.destination as Record<string, unknown>)
+      : null;
+  const collection =
+    typeof destination?.collection === "string"
+      ? destination.collection
+      : undefined;
+  if (!collection) return undefined;
+  const { lineage } = await enforceCollectionEgressWithAudit({
+    collections: ctxHolder.config.collections,
+    collectionNames: [collection],
+    action: "clip_write",
+    destinationZone: "loopback",
+    caller: { authenticated: true, operationAuthorized: true },
+    contentClass: "source",
+    store,
+  });
+  return lineage;
+};
+
 export function createClipperRouteGateway(
   ctxHolder: ContextHolder,
   store: SqliteAdapter,
@@ -279,7 +319,12 @@ export function createClipperRouteGateway(
     if (!authenticated.ok) return authenticated.response;
     const { admission, grant } = authenticated.value;
     try {
-      const prepared = prepareBrowserClip(admission.body);
+      const egressLineage = await enforceClipWrite(
+        ctxHolder,
+        store,
+        admission.body
+      );
+      const prepared = prepareBrowserClip(admission.body, { egressLineage });
       const planned = await planResidentCapture(
         ctxHolder,
         store,
@@ -303,6 +348,12 @@ export function createClipperRouteGateway(
         admission.origin
       );
     } catch (error) {
+      if (error instanceof EgressDeniedError) {
+        return withClipperCors(
+          clipperErrorResponse("EGRESS_DENIED", EGRESS_DENIED_MESSAGE, 403),
+          admission.origin
+        );
+      }
       return withClipperCors(
         clipperErrorResponse(
           "CLIPPER_INVALID_REQUEST",
@@ -321,6 +372,11 @@ export function createClipperRouteGateway(
     if (!authenticated.ok) return authenticated.response;
     const { admission, grant } = authenticated.value;
     try {
+      const egressLineage = await enforceClipWrite(
+        ctxHolder,
+        store,
+        admission.body
+      );
       return withClipperCors(
         await executeClipperCapture({
           request,
@@ -330,10 +386,17 @@ export function createClipperRouteGateway(
           context: ctxHolder,
           store,
           pairing,
+          egressLineage,
         }),
         admission.origin
       );
     } catch (error) {
+      if (error instanceof EgressDeniedError) {
+        return withClipperCors(
+          clipperErrorResponse("EGRESS_DENIED", EGRESS_DENIED_MESSAGE, 403),
+          admission.origin
+        );
+      }
       return withClipperCors(
         clipperErrorResponse(
           "CLIPPER_CAPTURE_FAILED",

package/src/serve/routes/mcp.ts

@@ -44,6 +44,9 @@ export async function createMcpHttpGateway(
   (runtime as Partial<ResidentRuntime>).setTransportStatusProvider?.(() =>
     transport.getStatus()
   );
+  (runtime as Partial<ResidentRuntime>).setPolicySessionInvalidator?.(() =>
+    transport.invalidateAuthenticatedSessions()
+  );
 
   const route: McpHttpRoute = async (request, server) => {
     const authorization = await security.authorize(request, server);
@@ -52,8 +55,10 @@ export async function createMcpHttpGateway(
     // POST responses and GET streams may both be long-lived SSE responses.
     server.timeout(request, 0);
     return transport.handleRequest(authorization.value.request, {
+      authenticated: authorization.value.authenticated,
       identity: authorization.value.identity,
       parsedBody: authorization.value.parsedBody,
+      peerClassification: authorization.value.peerClassification,
     });
   };
 
@@ -64,6 +69,7 @@ export async function createMcpHttpGateway(
     close: async () => {
       await transport.close();
       (runtime as Partial<ResidentRuntime>).setTransportStatusProvider?.(null);
+      (runtime as Partial<ResidentRuntime>).setPolicySessionInvalidator?.(null);
     },
   };
 }