@vibe-agent-toolkit/resources 0.1.39-rc.9 → 0.1.39

package/src/schemas/link-auth.ts

@@ -3,24 +3,26 @@
  *
  * Validates the shape of an adopter's linkAuth configuration: providers
  * (each either a `use: <macro>` reference or a full inline provider) plus
- * an optional cache config. Strict — typos in provider field names are
- * errors, per Postel's law ("writing our output → conservative").
+ * an optional cache config. **Passthrough** — per the repo Postel's Law
+ * rule, schemas that parse external data (adopter `vibe-agent-toolkit.config.yaml`)
+ * are liberal: unknown fields pass through rather than abort the parse, so
+ * an adopter with a forward-compatible field or a typo gets `vat resources
+ * validate` degrading gracefully instead of crashing. Typo-catching DX is
+ * a separate lint/warn pass, not a hard parse failure.
  *
  * Provider entries accept EITHER:
  *   - `{ use: <name>, ...overrides }` — reference a shipped macro by name;
- *     override fields are deep-merged on top at expansion time. Overrides
- *     are NOT strictly typed at this layer because they must match the
- *     macro's shape, which we cannot see until expansion. A typo in an
- *     override silently no-ops; the full provider shape is validated
- *     after expansion (slice 2 wires that).
- *   - A full inline `{ match, rewrite, auth, token, check }` — every field
- *     required, every nested object strict.
+ *     override fields are deep-merged on top at expansion time.
+ *   - A full inline `{ match, rewrite, auth, token, check }` — every required
+ *     field present, with declared-field types still enforced (passthrough
+ *     only relaxes unknown-key handling, not type checking on known fields).
  *
  * Mirrors the runtime types in `@vibe-agent-toolkit/utils`'s `link-auth/`
  * module. Keep these aligned: a config that parses here must satisfy the
  * `Provider` / `LinkAuthConfig` interfaces over there.
  *
- * Per design issue #113 §4 (vocabulary) and §5 (macros).
+ * Per design issue #113 §4 (vocabulary) and §5 (macros), and the repo
+ * CLAUDE.md Postel's Law rule for adopter-facing configs.
  */
 
 import { z } from 'zod';
@@ -37,7 +39,7 @@ export const ProviderMatchSchema = z
       .optional()
       .describe('Globs that, if any match the hostname, exclude this provider'),
   })
-  .strict()
+  .passthrough()
   .describe('Provider selection — match.host + optional excludeHost globs');
 
 export const RewriteRuleSchema = z
@@ -49,7 +51,7 @@ export const RewriteRuleSchema = z
       .describe('Computed variables, each a template that references captures from `when`'),
     to: z.string().min(1).describe('URL template — interpolates ${capture} and ${var}'),
   })
-  .strict()
+  .passthrough()
   .describe('A single rewrite rule (one entry in a provider\'s ordered rewrite list)');
 
 export const ProviderAuthSchema = z
@@ -58,17 +60,32 @@ export const ProviderAuthSchema = z
       .record(z.string(), z.string())
       .describe('Header name → value template. Values interpolate ${token} and any capture/var.'),
   })
-  .strict()
+  .passthrough()
   .describe('Auth headers attached to the authenticated fetch');
 
+/**
+ * Optional fetch-mode header overrides (§6.2). Same shape as ProviderAuth,
+ * different role: `auth.headers` covers the health-check request; `fetch.headers`
+ * covers content retrieval (e.g. GitHub `application/vnd.github.raw` instead of
+ * `application/vnd.github+json`). Both templates expand against the same context.
+ */
+export const ProviderFetchSchema = z
+  .object({
+    headers: z
+      .record(z.string(), z.string())
+      .describe('Header name → value template, same templating as auth.headers.'),
+  })
+  .passthrough()
+  .describe('Optional content-fetch header overrides — distinct from health-check headers');
+
 export const TokenSourceSchema = z
   .union([
-    z.object({ env: z.string().min(1) }).strict(),
+    z.object({ env: z.string().min(1) }).passthrough(),
     z
       .object({
         command: z.union([z.string().min(1), z.array(z.string().min(1)).min(1)]),
       })
-      .strict(),
+      .passthrough(),
   ])
   .describe('A single token source — env var, or argv command (preferred), or convenience string');
 
@@ -85,22 +102,25 @@ export const ProviderCheckSchema = z
         'Per-host: does 404 mean "dead" (honest 404 host like Graph) or "ambiguous" (masking host like GitHub)?',
       ),
   })
-  .strict()
+  .passthrough()
   .describe('Status-to-outcome classifier (consumed by the resources layer, not the pure engine)');
 
 // ---------------------------------------------------------------------------
 // Provider entry (inline OR macro reference)
 // ---------------------------------------------------------------------------
 
-const InlineProviderSchema = z
+export const InlineProviderSchema = z
   .object({
     match: ProviderMatchSchema,
     rewrite: z.array(RewriteRuleSchema).min(1).describe('Ordered rewrite rules — first matching wins'),
     auth: ProviderAuthSchema,
+    fetch: ProviderFetchSchema
+      .optional()
+      .describe('Optional fetch-mode header override (§6.2) — content retrieval, distinct from health-check'),
     token: z.array(TokenSourceSchema).describe('Ordered token sources — first non-empty wins'),
     check: ProviderCheckSchema,
   })
-  .strict();
+  .passthrough();
 
 const MacroProviderSchema = z
   .object({
@@ -128,7 +148,7 @@ export const LinkAuthCacheSchema = z
       .optional()
       .describe('Content cache TTL in minutes (default 30 — used by slice 3 content-fetch)'),
   })
-  .strict();
+  .passthrough();
 
 export const LinkAuthConfigSchema = z
   .object({
@@ -137,10 +157,16 @@ export const LinkAuthConfigSchema = z
       .array(ProviderEntrySchema)
       .describe('Ordered list of providers — first claiming-by-host wins'),
   })
-  .strict()
+  .passthrough()
   .describe('`resources.linkAuth` — authenticated external link resolution config');
 
-export type LinkAuthConfig = z.infer<typeof LinkAuthConfigSchema>;
+/**
+ * Adopter-facing config shape — what an `vibe-agent-toolkit.config.yaml`
+ * parses to. Distinct from `@vibe-agent-toolkit/utils`'s `LinkAuthConfig`
+ * (the engine shape, with fully-expanded providers only). The bridge
+ * function `buildLinkAuthEngineConfig` converts between the two.
+ */
+export type LinkAuthProjectConfig = z.infer<typeof LinkAuthConfigSchema>;
 export type ProviderEntry = z.infer<typeof ProviderEntrySchema>;
 export type RewriteRule = z.infer<typeof RewriteRuleSchema>;
 export type TokenSource = z.infer<typeof TokenSourceSchema>;

package/src/schemas/project-config.ts

@@ -1,4 +1,5 @@
 import { ValidationConfigSchema } from '@vibe-agent-toolkit/agent-schema';
+import { hasParentTraversalSegment, isAbsoluteAnyPlatform } from '@vibe-agent-toolkit/utils';
 import { z } from 'zod';
 
 import { LinkAuthConfigSchema } from './link-auth.js';
@@ -132,10 +133,26 @@ export const ExcludeReferencesFromBundleSchema = z.object({
  * Used for build artifacts, unlinked files, and routing overrides.
  * - source: path relative to project root (where vibe-agent-toolkit.config.yaml lives)
  * - dest: path relative to the skill's output directory (sibling to SKILL.md)
+ * - integrity (optional): byte-verify the copied set against the matched source set at build time
  */
 export const SkillFileEntrySchema = z.object({
   source: z.string().min(1).describe('Source path relative to project root'),
-  dest: z.string().min(1).describe('Destination path relative to skill output directory'),
+  dest: z.string().min(1)
+    // Containment guard (zip-slip class): dest is OUR config output and is joined
+    // onto the skill output directory at build time, so it must stay inside it.
+    // Reject absolute paths (POSIX `/…`, Windows `C:\…`, UNC) and any `..`
+    // traversal segment. Defense-in-depth: copy sites also route through
+    // safePath.joinUnderRoot().
+    .refine(
+      (d) => !isAbsoluteAnyPlatform(d) && !hasParentTraversalSegment(d),
+      {
+        message:
+          'dest must be a relative path contained in the skill output directory: ' +
+          'no absolute paths (e.g. "/etc/x" or a Windows drive path) and no ".." traversal segments',
+      },
+    )
+    .describe('Destination path relative to skill output directory'),
+  integrity: z.boolean().optional().describe('When true, the build asserts the copied dest set exactly matches the matched source set and each file is byte-identical (a future copy-time check; late-bound)'),
 });
 
 export type SkillFileEntry = z.infer<typeof SkillFileEntrySchema>;
@@ -196,6 +213,10 @@ export const TestConfigSchema = z.object({
    * that is produced by a bundler step and not committed to source.
    * A non-zero exit code aborts the run (preflight failure, exit 2).
    */
+  env: z.record(z.string(), z.string()).optional()
+    .describe('Feature B: explicit env var injections for the experimenter spawn. Values support ${fixturesDir}, ${stagedSkillDir}, ${harnessRoot}, ${resultsDir} interpolation (resolved at stage time). Protected names (PATH, auth, model, admin) cannot be overridden.'),
+  passEnv: z.array(z.string().min(1)).optional()
+    .describe('Feature A: names of host env vars to forward to the experimenter spawn if present. Protected names are ignored with a warning.'),
   build: z.string().min(1).optional()
     .describe('Shell command run once, before staging, to generate build artifacts (cwd = config root)'),
 }).strict().describe('Per-skill vat skill test configuration');

package/src/schemas/resource-metadata.ts

@@ -10,6 +10,7 @@ import { SHA256Schema } from './checksum.js';
  * - `anchor`: Link to a heading anchor (e.g., #heading-slug)
  * - `external`: HTTP/HTTPS URL to external resource
  * - `email`: Mailto link
+ * - `embedded`: Self-contained inline resource (`data:`/`blob:` URI) — no target to validate
  * - `unknown`: Unclassified link type
  */
 export const LinkTypeSchema = z.enum([
@@ -18,6 +19,7 @@ export const LinkTypeSchema = z.enum([
   'anchor',
   'external',
   'email',
+  'embedded',
   'unknown',
 ]).describe('Type of link found in markdown resources');