@gmickel/gno 1.28.0 → 1.29.1

package/src/sdk/client.ts

@@ -79,6 +79,11 @@ import {
   planCapture,
 } from "../core/capture";
 import { writeCapturePlanFile } from "../core/capture-write";
+import { projectCollectionEgressPolicy } from "../core/collection-egress-policy-projection";
+import { CollectionEgressPolicyService } from "../core/collection-egress-policy-service";
+import { applyConfigChange } from "../core/config-mutation";
+import { EgressAuditService } from "../core/egress-audit";
+import { authorizeCurrentEgress } from "../core/egress-authorization";
 import {
   atomicWrite,
   copyFilePath,
@@ -270,7 +275,7 @@ async function resolveClientState(
 }
 
 class GnoClientImpl implements GnoClient {
-  readonly config: Config;
+  config: Config;
   readonly dbPath: string;
   readonly configPath: string | null;
   readonly configSource: "file" | "inline";
@@ -331,6 +336,9 @@ class GnoClientImpl implements GnoClient {
     rerankModel?: string;
   }): Promise<RuntimePorts> {
     this.assertOpen();
+    const egressCollections = options.collection
+      ? [options.collection]
+      : ("all" as const);
 
     let embedPort: EmbeddingPort | null = null;
     let expandPort: GenerationPort | null = null;
@@ -347,6 +355,7 @@ class GnoClientImpl implements GnoClient {
           options.collection
         ),
         {
+          egressCollections,
           policy: this.downloadPolicy,
         }
       );
@@ -391,6 +400,7 @@ class GnoClientImpl implements GnoClient {
           options.collection
         ),
         {
+          egressCollections,
           policy: this.downloadPolicy,
         }
       );
@@ -415,6 +425,7 @@ class GnoClientImpl implements GnoClient {
           options.collection
         ),
         {
+          egressCollections,
           policy: this.downloadPolicy,
         }
       );
@@ -442,6 +453,7 @@ class GnoClientImpl implements GnoClient {
           options.collection
         ),
         {
+          egressCollections,
           policy: this.downloadPolicy,
         }
       );
@@ -1230,7 +1242,19 @@ class GnoClientImpl implements GnoClient {
   ) {
     this.assertOpen();
     return unwrapTraceStore(
-      await new RetrievalTraceManagementService(this.store).export(input)
+      await new RetrievalTraceManagementService(this.store, {
+        authorizeExport: async (lineage) => {
+          return authorizeCurrentEgress({
+            store: this.store,
+            config: this.config,
+            lineage,
+            action: "export",
+            destinationZone: "local_process",
+            caller: { authenticated: true, operationAuthorized: true },
+            contentClass: "retrieval_trace",
+          });
+        },
+      }).export(input)
     );
   }
 
@@ -1248,6 +1272,99 @@ class GnoClientImpl implements GnoClient {
     );
   }
 
+  async getCollectionEgressPolicy(collection: string) {
+    this.assertOpen();
+    const state = new CollectionEgressPolicyService({
+      getConfig: () => this.config,
+    }).get(collection);
+    if (!state.ok) {
+      throw sdkError(
+        state.code === "NOT_FOUND" ? "NOT_FOUND" : "VALIDATION",
+        state.error
+      );
+    }
+    return state.value;
+  }
+
+  async setCollectionEgressPolicy(
+    collection: string,
+    policy: import("../config/types").EgressPolicy,
+    confirmation?: import("../core/collection-egress-policy-service").EgressRelaxationConfirmation
+  ) {
+    this.assertOpen();
+    if (!this.configPath) {
+      throw sdkError(
+        "VALIDATION",
+        "Inline-config clients cannot persist collection policy changes"
+      );
+    }
+    const service = new CollectionEgressPolicyService({
+      getConfig: () => this.config,
+      mutateConfig: (mutate) =>
+        applyConfigChange(
+          {
+            store: this.store,
+            configPath: this.configPath ?? undefined,
+            onConfigUpdated: (config) => {
+              this.config = config;
+            },
+            projectStore: (store, config) =>
+              projectCollectionEgressPolicy(store, config, collection),
+          },
+          mutate
+        ),
+    });
+    const result = await service.set({
+      collection,
+      policy,
+      confirmation,
+    });
+    if (!result.ok) throw sdkError("VALIDATION", result.error);
+    return result.value;
+  }
+
+  async checkEgress(
+    input: import("../core/collection-egress-policy-service").CollectionEgressCheckInput
+  ) {
+    this.assertOpen();
+    const result = new CollectionEgressPolicyService({
+      getConfig: () => this.config,
+    }).check(input);
+    if (!result.ok) throw sdkError("VALIDATION", result.error);
+    return result.value;
+  }
+
+  async listEgressAudits(options: { limit?: number; cursor?: string } = {}) {
+    this.assertOpen();
+    return unwrapTraceStore(
+      await new EgressAuditService(this.store).list(options)
+    );
+  }
+
+  async getEgressAudit(auditId: string) {
+    this.assertOpen();
+    return unwrapTraceStore(
+      await new EgressAuditService(this.store).show(auditId)
+    );
+  }
+
+  async getEgressAuditStatus() {
+    this.assertOpen();
+    return unwrapTraceStore(await new EgressAuditService(this.store).status());
+  }
+
+  async deleteEgressAudit(auditId: string) {
+    this.assertOpen();
+    return unwrapTraceStore(
+      await new EgressAuditService(this.store).delete(auditId)
+    );
+  }
+
+  async purgeEgressAudits() {
+    this.assertOpen();
+    return unwrapTraceStore(await new EgressAuditService(this.store).purge());
+  }
+
   async update(options: GnoUpdateOptions = {}): Promise<SyncResult> {
     this.assertOpen();
     const collections = this.getCollections(options.collection);

package/src/sdk/embed.ts

@@ -283,6 +283,7 @@ export async function runEmbed(
   }
 
   const embedResult = await runtime.llm.createEmbeddingPort(modelUri, {
+    egressCollections: options.collection ? [options.collection] : "all",
     policy: runtime.downloadPolicy,
   });
   if (!embedResult.ok) {

package/src/sdk/types.ts

@@ -11,6 +11,13 @@ import type {
 import type { ContentTypeBoostStatus } from "../config/content-types";
 import type { Config } from "../config/types";
 import type { CaptureInput, CaptureReceipt } from "../core/capture";
+import type {
+  CollectionEgressCheckInput,
+  CollectionEgressCheckResult,
+  CollectionEgressPolicySetResult,
+  CollectionEgressPolicyState,
+  EgressRelaxationConfirmation,
+} from "../core/collection-egress-policy-service";
 import type {
   ContextCapsuleErrorCode,
   ContextCapsuleV1,
@@ -18,6 +25,13 @@ import type {
 } from "../core/context-capsule";
 import type { ContextEvidenceErrorCode } from "../core/context-evidence";
 import type { ContextVerifierErrorCode } from "../core/context-verifier";
+import type {
+  EgressAuditDeleteResult,
+  EgressAuditListResult,
+  EgressAuditPurgeManagementResult,
+  EgressAuditShowResult,
+  EgressAuditStatusResult,
+} from "../core/egress-audit";
 import type {
   KnowledgeChangesResult,
   KnowledgeDiffResult,
@@ -300,6 +314,25 @@ export interface GnoClient {
   ): Promise<RetrievalTraceExportResult>;
   deleteRetrievalTrace(traceId: string): Promise<RetrievalTraceDeleteResult>;
   purgeRetrievalTraces(): Promise<RetrievalTraceManagementPurgeResult>;
+  getCollectionEgressPolicy(
+    collection: string
+  ): Promise<CollectionEgressPolicyState>;
+  setCollectionEgressPolicy(
+    collection: string,
+    policy: import("../config/types").EgressPolicy,
+    confirmation?: EgressRelaxationConfirmation
+  ): Promise<CollectionEgressPolicySetResult>;
+  checkEgress(
+    input: CollectionEgressCheckInput
+  ): Promise<CollectionEgressCheckResult>;
+  listEgressAudits(options?: {
+    limit?: number;
+    cursor?: string;
+  }): Promise<EgressAuditListResult>;
+  getEgressAudit(auditId: string): Promise<EgressAuditShowResult>;
+  getEgressAuditStatus(): Promise<EgressAuditStatusResult>;
+  deleteEgressAudit(auditId: string): Promise<EgressAuditDeleteResult>;
+  purgeEgressAudits(): Promise<EgressAuditPurgeManagementResult>;
   update(options?: GnoUpdateOptions): Promise<SyncResult>;
   embed(options?: GnoEmbedOptions): Promise<GnoEmbedResult>;
   index(options?: GnoIndexOptions): Promise<GnoIndexResult>;

package/src/serve/clipper-capture.ts

@@ -3,6 +3,7 @@
 import type { Database } from "bun:sqlite";
 
 import type { PreparedBrowserClip } from "../core/browser-clip";
+import type { EgressLineage } from "../core/egress-provenance";
 import type { SqliteAdapter } from "../store/sqlite/adapter";
 import type { ClipperIdempotencyReplay } from "../store/sqlite/clipper-store-types";
 import type { ResidentCaptureContext } from "./capture-service";
@@ -35,6 +36,7 @@ interface ExecuteClipperCaptureInput {
   context: ResidentCaptureContext;
   store: SqliteAdapter;
   pairing: ClipperPairingService;
+  egressLineage?: EgressLineage;
 }
 
 const inFlightRequests = new Set<string>();
@@ -153,7 +155,9 @@ export const executeClipperCapture = async (
     );
   }
 
-  const prepared = prepareBrowserClip(parsed.data.payload);
+  const prepared = prepareBrowserClip(parsed.data.payload, {
+    egressLineage: input.egressLineage,
+  });
   if (prepared.preview.digest !== parsed.data.previewDigest) {
     return clipperErrorResponse(
       "CLIPPER_PREVIEW_MISMATCH",

package/src/serve/closed-json.ts

@@ -0,0 +1,61 @@
+/** Bounded, content-free JSON request parsing for closed REST contracts. */
+
+const DEFAULT_MAX_BYTES = 16 * 1024;
+
+export type ClosedJsonResult =
+  | { ok: true; value: unknown }
+  | { ok: false; code: "VALIDATION"; error: string };
+
+export const parseClosedJson = async (
+  request: Request,
+  maxBytes = DEFAULT_MAX_BYTES
+): Promise<ClosedJsonResult> => {
+  try {
+    const contentLength = Number(request.headers.get("content-length"));
+    if (Number.isFinite(contentLength) && contentLength > maxBytes) {
+      return {
+        ok: false,
+        code: "VALIDATION",
+        error: "JSON body exceeds the allowed size",
+      };
+    }
+    const reader = request.body?.getReader();
+    if (!reader) {
+      return {
+        ok: false,
+        code: "VALIDATION",
+        error: "Invalid JSON body",
+      };
+    }
+    const chunks: Uint8Array[] = [];
+    let totalBytes = 0;
+    while (true) {
+      const chunk = await reader.read();
+      if (chunk.done) break;
+      totalBytes += chunk.value.byteLength;
+      if (totalBytes > maxBytes) {
+        await reader.cancel("JSON body exceeds the allowed size");
+        return {
+          ok: false,
+          code: "VALIDATION",
+          error: "JSON body exceeds the allowed size",
+        };
+      }
+      chunks.push(chunk.value);
+    }
+    const bytes = new Uint8Array(totalBytes);
+    let offset = 0;
+    for (const chunk of chunks) {
+      bytes.set(chunk, offset);
+      offset += chunk.byteLength;
+    }
+    const text = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+    return { ok: true, value: JSON.parse(text) as unknown };
+  } catch {
+    return {
+      ok: false,
+      code: "VALIDATION",
+      error: "Invalid JSON body",
+    };
+  }
+};

package/src/serve/config-sync.ts

@@ -11,6 +11,7 @@ import type { ContextHolder } from "./routes/api";
 
 import {
   applyConfigChange as applyConfigChangeCore,
+  type ConfigMutationContext,
   type ApplyConfigResult,
   type MutationResult,
 } from "../core/config-mutation";
@@ -67,11 +68,13 @@ export async function applyConfigChangeTyped<T>(
   ctxHolder: ContextHolder,
   store: SqliteAdapter,
   mutate: (config: Config) => Promise<MutationResult<T>> | MutationResult<T>,
-  configPath?: string
+  configPath?: string,
+  options: Pick<ConfigMutationContext, "projectStore"> = {}
 ): Promise<ApplyConfigResult<T>> {
   const result = await applyConfigChangeCore(
     {
       store,
+      projectStore: options.projectStore,
       configPath: configPath ?? ctxHolder.actualConfigPath,
       onConfigUpdated: (config) => {
         ctxHolder.config = config;

package/src/serve/context.ts

@@ -115,6 +115,7 @@ export async function createServerContext(
 
     // Progress callback updates downloadState for WebUI polling
     const createPortOptions = (type: ModelType): CreatePortOptions => ({
+      egressCollections: "all",
       policy,
       onProgress: (progress) => {
         downloadState.active = true;

package/src/serve/doc-events.ts

@@ -25,46 +25,87 @@ export interface DocumentEventBusState {
   retryMs: number;
 }
 
+export interface DocumentEventStreamAuthorization {
+  authorizationEpoch: string;
+  isAuthorizationEpochCurrent: () => boolean;
+  onClose?: () => void;
+  signal?: AbortSignal;
+}
+
+interface DocumentEventSubscriber {
+  authorization: DocumentEventStreamAuthorization;
+  closed: boolean;
+  controller: ReadableStreamDefaultController<Uint8Array>;
+  keepaliveTimer: ReturnType<typeof setInterval> | null;
+  removeAbortListener: (() => void) | null;
+}
+
 const encoder = new TextEncoder();
 const EVENT_RETRY_MS = 2_000;
 const KEEPALIVE_MS = 15_000;
+const POLICY_CHANGED_FRAME = encoder.encode(
+  `retry: ${EVENT_RETRY_MS}\nevent: egress-policy-changed\ndata: {"error":{"code":"EGRESS_POLICY_CHANGED","message":"Collection policy changed; retry"}}\n\n`
+);
 
 export class DocumentEventBus {
-  readonly #controllers = new Set<
-    ReadableStreamDefaultController<Uint8Array>
-  >();
-
-  createResponse(): Response {
-    const controllers = this.#controllers;
-    let streamController: ReadableStreamDefaultController<Uint8Array> | null =
-      null;
-    let keepaliveTimer: ReturnType<typeof setInterval> | null = null;
+  readonly #subscribers = new Set<DocumentEventSubscriber>();
+  readonly #keepaliveMs: number;
+
+  constructor(options: { keepaliveMs?: number } = {}) {
+    this.#keepaliveMs = options.keepaliveMs ?? KEEPALIVE_MS;
+  }
+
+  createResponse(
+    authorization: DocumentEventStreamAuthorization = {
+      authorizationEpoch: "unrestricted",
+      isAuthorizationEpochCurrent: () => true,
+    }
+  ): Response {
+    let subscriber: DocumentEventSubscriber | null = null;
     const stream = new ReadableStream<Uint8Array>({
-      start(controller) {
-        streamController = controller;
-        controllers.add(controller);
+      start: (controller) => {
+        subscriber = {
+          authorization,
+          closed: false,
+          controller,
+          keepaliveTimer: null,
+          removeAbortListener: null,
+        };
+        this.#subscribers.add(subscriber);
+        if (!authorization.isAuthorizationEpochCurrent()) {
+          this.#invalidateSubscriber(subscriber);
+          return;
+        }
         controller.enqueue(
           encoder.encode(`retry: ${EVENT_RETRY_MS}\n: connected\n\n`)
         );
-        keepaliveTimer = setInterval(() => {
-          try {
-            controller.enqueue(encoder.encode(": keepalive\n\n"));
-          } catch {
-            if (keepaliveTimer) {
-              clearInterval(keepaliveTimer);
+        subscriber.keepaliveTimer = setInterval(
+          () => {
+            if (!authorization.isAuthorizationEpochCurrent()) {
+              this.#invalidateSubscriber(subscriber);
+              return;
             }
-            controllers.delete(controller);
-          }
-        }, KEEPALIVE_MS);
-      },
-      cancel() {
-        if (keepaliveTimer) {
-          clearInterval(keepaliveTimer);
-        }
-        if (streamController) {
-          controllers.delete(streamController);
+            try {
+              controller.enqueue(encoder.encode(": keepalive\n\n"));
+            } catch {
+              this.#closeSubscriber(subscriber);
+            }
+          },
+          this.#keepaliveMs
+        );
+        if (authorization.signal) {
+          const onAbort = (): void => this.#closeSubscriber(subscriber);
+          authorization.signal.addEventListener("abort", onAbort, {
+            once: true,
+          });
+          subscriber.removeAbortListener = () =>
+            authorization.signal?.removeEventListener("abort", onAbort);
+          if (authorization.signal.aborted) onAbort();
         }
       },
+      cancel: () => {
+        this.#closeSubscriber(subscriber, false);
+      },
     });
 
     return new Response(stream, {
@@ -81,30 +122,60 @@ export class DocumentEventBus {
       `event: ${event.type}\ndata: ${JSON.stringify(event)}\n\n`
     );
 
-    for (const controller of this.#controllers) {
+    for (const subscriber of this.#subscribers) {
+      if (!subscriber.authorization.isAuthorizationEpochCurrent()) {
+        this.#invalidateSubscriber(subscriber);
+        continue;
+      }
       try {
-        controller.enqueue(payload);
+        subscriber.controller.enqueue(payload);
       } catch {
-        this.#controllers.delete(controller);
+        this.#closeSubscriber(subscriber);
       }
     }
   }
 
   close(): void {
-    for (const controller of this.#controllers) {
-      try {
-        controller.close();
-      } catch {
-        // Best-effort shutdown.
-      }
+    for (const subscriber of this.#subscribers) {
+      this.#closeSubscriber(subscriber);
     }
-    this.#controllers.clear();
   }
 
   getState(): DocumentEventBusState {
     return {
-      connectedClients: this.#controllers.size,
+      connectedClients: this.#subscribers.size,
       retryMs: EVENT_RETRY_MS,
     };
   }
+
+  #invalidateSubscriber(subscriber: DocumentEventSubscriber | null): void {
+    if (!subscriber || subscriber.closed) return;
+    try {
+      subscriber.controller.enqueue(POLICY_CHANGED_FRAME);
+    } catch {
+      // The stream may already be cancelled.
+    }
+    this.#closeSubscriber(subscriber);
+  }
+
+  #closeSubscriber(
+    subscriber: DocumentEventSubscriber | null,
+    closeController = true
+  ): void {
+    if (!subscriber || subscriber.closed) return;
+    subscriber.closed = true;
+    if (subscriber.keepaliveTimer) {
+      clearInterval(subscriber.keepaliveTimer);
+    }
+    subscriber.removeAbortListener?.();
+    this.#subscribers.delete(subscriber);
+    if (closeController) {
+      try {
+        subscriber.controller.close();
+      } catch {
+        // Best-effort stream shutdown.
+      }
+    }
+    subscriber.authorization.onClose?.();
+  }
 }