@gmickel/gno 1.27.1 → 1.29.0

package/src/ingestion/walker.ts

@@ -21,6 +21,7 @@ import type { SkippedEntry, WalkConfig, WalkEntry, WalkerPort } from "./types";
 
 import { SUPPORTED_EXTENSIONS } from "../converters/mime";
 import { matchesCollectionExclusion } from "../core/path-rules";
+import { isRecordVirtualPath } from "./record-path";
 
 /**
  * Regex to detect dangerous patterns with parent directory traversal.
@@ -124,7 +125,7 @@ function scanPatterns(pattern: string): string[] {
 async function safeRelPath(
   rootReal: string,
   absPath: string
-): Promise<string | null> {
+): Promise<{ absPath: string; relPath: string } | null> {
   try {
     const fileReal = await realpath(absPath);
     const rel = relative(rootReal, fileReal);
@@ -135,7 +136,7 @@ async function safeRelPath(
       return null;
     }
 
-    return toPosixPath(rel);
+    return { absPath: fileReal, relPath: toPosixPath(rel) };
   } catch {
     // Can't resolve path (e.g., broken symlink)
     return null;
@@ -145,18 +146,25 @@ async function safeRelPath(
 /**
  * Check if a file extension matches the include list.
  * Include list contains extensions like ".md" or "md" (normalized).
- * When include is empty, falls back to SUPPORTED_EXTENSIONS to avoid
- * walking files that can't be converted.
+ * When include is empty, falls back to SUPPORTED_EXTENSIONS plus extensions
+ * made convertible by explicit adapter configuration.
  */
-function matchesInclude(relPath: string, include: string[]): boolean {
+function matchesInclude(
+  relPath: string,
+  include: string[],
+  additionalDefaultExtensions: string[]
+): boolean {
   const ext = extname(relPath).toLowerCase();
   if (!ext) {
     return false;
   }
 
-  // Fallback to supported extensions when no explicit include list
+  if (include.length === 0 && SUPPORTED_EXTENSIONS.includes(ext)) {
+    return true;
+  }
+
   const effectiveInclude =
-    include.length === 0 ? SUPPORTED_EXTENSIONS : include;
+    include.length === 0 ? additionalDefaultExtensions : include;
 
   return effectiveInclude.some((inc) => {
     const normalizedInc = inc.startsWith(".")
@@ -211,13 +219,19 @@ export class FileWalker implements WalkerPort {
       }
     }
 
-    for (const absPath of [...matches].sort()) {
+    for (const matchedPath of [...matches].sort()) {
       // Security: Compute safe relative path (validates file is within root)
-      const relPath = await safeRelPath(rootReal, absPath);
-      if (relPath === null) {
+      const safePath = await safeRelPath(rootReal, matchedPath);
+      if (safePath === null) {
         // File outside root or unresolvable - silently skip (security)
         continue;
       }
+      const { absPath, relPath } = safePath;
+
+      if (isRecordVirtualPath(relPath)) {
+        skipped.push({ absPath, relPath, reason: "EXCLUDED" });
+        continue;
+      }
 
       // Check exclude patterns
       if (matchesCollectionExclusion(relPath, config.exclude)) {
@@ -230,7 +244,13 @@ export class FileWalker implements WalkerPort {
       }
 
       // Check include extensions
-      if (!matchesInclude(relPath, config.include)) {
+      if (
+        !matchesInclude(
+          relPath,
+          config.include,
+          config.additionalDefaultExtensions ?? []
+        )
+      ) {
         skipped.push({
           absPath,
           relPath,

package/src/llm/errors.ts

@@ -18,6 +18,7 @@ export type LlmErrorCode =
   | "INVALID_MODEL_FILE"
   | "MODEL_DOWNLOAD_INTERCEPTED"
   | "INFERENCE_FAILED"
+  | "EGRESS_DENIED"
   | "TIMEOUT"
   | "OUT_OF_MEMORY"
   | "INVALID_URI"
@@ -202,6 +203,15 @@ export function inferenceFailedError(uri: string, cause?: unknown): LlmError {
   });
 }
 
+export function egressDeniedInferenceError(cause?: unknown): LlmError {
+  return llmError("EGRESS_DENIED", {
+    message: "Operation blocked by collection egress policy",
+    retryable: false,
+    cause,
+    suggestion: "Review the collection egress policy and model destination.",
+  });
+}
+
 export function timeoutError(
   uri: string,
   operation: "load" | "inference",

package/src/llm/http-inference.ts

@@ -0,0 +1,175 @@
+/** Policy-gated, DNS-pinned HTTP transport shared by inference adapters. */
+
+import type { Collection } from "../config/types";
+import type { CollectionEgressState } from "../core/egress-policy";
+import type { EgressDestinationZone } from "../core/egress-policy";
+import type {
+  HttpDestinationPolicyOptions,
+  HttpDestinationResolver,
+  PinnedHttpFetch,
+} from "./http-policy";
+
+import {
+  collectionEgressStates,
+  EgressDeniedError,
+  maximumDestinationZoneForCollections,
+} from "../core/egress-enforcement";
+import { evaluateEgressPolicy } from "../core/egress-policy";
+import { EgressProvenanceError } from "../core/egress-provenance";
+import { classifyHttpDestination, prepareHttpDestination } from "./http-policy";
+
+const REDIRECT_STATUSES = new Set([301, 302, 307, 308]);
+
+export interface HttpInferenceOptions {
+  collections: readonly Collection[];
+  collectionNames: readonly string[];
+  authenticated?: boolean;
+  operationAuthorized?: boolean;
+  resolver?: HttpDestinationResolver;
+  fetchFn?: PinnedHttpFetch;
+  env?: HttpDestinationPolicyOptions["env"];
+}
+
+const scopedStates = (
+  options: HttpInferenceOptions
+): readonly CollectionEgressState[] => {
+  try {
+    return collectionEgressStates(options.collections, options.collectionNames);
+  } catch (error) {
+    if (error instanceof EgressProvenanceError) return [];
+    throw error;
+  }
+};
+
+const enforce = (
+  states: readonly CollectionEgressState[],
+  zone: EgressDestinationZone,
+  options: HttpInferenceOptions
+): void => {
+  const decision = evaluateEgressPolicy({
+    collections: states,
+    action: "remote_inference",
+    destination: { zone },
+    caller: {
+      authenticated: options.authenticated ?? true,
+      operationAuthorized: options.operationAuthorized ?? true,
+    },
+    contentClass: "source",
+  });
+  if (!decision.allowed) throw new EgressDeniedError(decision);
+};
+
+export const requestHttpInference = async (
+  rawUrl: string,
+  init: BunFetchRequestInit,
+  options: HttpInferenceOptions
+): Promise<Response> => {
+  const states = scopedStates(options);
+  if (states.length === 0) {
+    enforce(states, "remote", options);
+  }
+  const maximumZone = maximumDestinationZoneForCollections(
+    options.collections,
+    options.collectionNames
+  );
+
+  // DNS-only classification carries no headers, body, credentials, or model
+  // metadata. Policy evaluates the proven zone before transport preparation.
+  const classification = await classifyHttpDestination(rawUrl, {
+    resolver: options.resolver,
+  });
+  if (!classification.ok) {
+    throw new EgressDeniedError(
+      evaluateEgressPolicy({
+        collections: states,
+        action: "remote_inference",
+        destination: { zone: classification.classification.zone },
+        caller: {
+          authenticated: options.authenticated ?? true,
+          operationAuthorized: false,
+        },
+        contentClass: "source",
+      })
+    );
+  }
+  enforce(states, classification.classification.zone, options);
+  const url = new URL(rawUrl);
+
+  let prepared = await prepareHttpDestination(url.href, {
+    maximumZone,
+    resolver: options.resolver,
+    remoteProvider: classification.classification.zone === "remote",
+    env: options.env,
+  });
+  if (!prepared.ok) {
+    throw new EgressDeniedError(
+      evaluateEgressPolicy({
+        collections: states,
+        action: "remote_inference",
+        destination: { zone: prepared.classification.zone },
+        caller: {
+          authenticated: options.authenticated ?? true,
+          operationAuthorized: false,
+        },
+        contentClass: "source",
+      })
+    );
+  }
+
+  let currentUrl = url;
+  for (;;) {
+    enforce(states, prepared.value.classification.zone, options);
+    const connection = await prepared.value.acquireConnection();
+    if (!connection.ok) {
+      throw new EgressDeniedError(
+        evaluateEgressPolicy({
+          collections: states,
+          action: "remote_inference",
+          destination: { zone: connection.classification.zone },
+          caller: {
+            authenticated: options.authenticated ?? true,
+            operationAuthorized: false,
+          },
+          contentClass: "source",
+        })
+      );
+    }
+    const response = await connection.value.request(init, options.fetchFn);
+    if (!REDIRECT_STATUSES.has(response.status)) return response;
+
+    const location = response.headers.get("location");
+    if (!location) return response;
+    const nextUrl = new URL(location, currentUrl);
+    if (nextUrl.origin.toLowerCase() !== currentUrl.origin.toLowerCase()) {
+      throw new EgressDeniedError(
+        evaluateEgressPolicy({
+          collections: states,
+          action: "remote_inference",
+          destination: { zone: prepared.value.classification.zone },
+          caller: {
+            authenticated: options.authenticated ?? true,
+            operationAuthorized: false,
+          },
+          contentClass: "source",
+        })
+      );
+    }
+    const next = await prepared.value.followRedirect(nextUrl.href);
+    if (!next.ok) {
+      throw new EgressDeniedError(
+        evaluateEgressPolicy({
+          collections: states,
+          action: "remote_inference",
+          destination: { zone: next.classification.zone },
+          caller: {
+            authenticated: options.authenticated ?? true,
+            operationAuthorized: false,
+          },
+          contentClass: "source",
+        })
+      );
+    }
+    currentUrl = nextUrl;
+    prepared = next;
+  }
+};