@envseal/protocol 0.1.3 → 0.1.4

package/dist/errors.d.ts

@@ -1,4 +1,4 @@
-export declare const SEP_ERROR_CODES: readonly ["SEP_UNKNOWN_KEY", "SEP_NOT_DECLARED", "SEP_NO_INTERACTIVE_SURFACE", "SEP_TICKET_EXPIRED", "SEP_TICKET_UNKNOWN", "SEP_USER_CANCELLED", "SEP_FORMAT_INVALID", "SEP_SINK_UNAVAILABLE", "SEP_SINK_WRITE_FAILED", "SEP_PROBE_NOT_APPROVED", "SEP_VALUE_IN_REQUEST", "SEP_GITIGNORE_UNSAFE", "SEP_CONFIRMATION_DENIED", "SEP_RATE_LIMITED", "SEP_TARGET_CHANGED"];
+export declare const SEP_ERROR_CODES: readonly ["SEP_UNKNOWN_KEY", "SEP_NOT_DECLARED", "SEP_NO_INTERACTIVE_SURFACE", "SEP_TICKET_EXPIRED", "SEP_TICKET_UNKNOWN", "SEP_USER_CANCELLED", "SEP_FORMAT_INVALID", "SEP_SINK_UNAVAILABLE", "SEP_SINK_WRITE_FAILED", "SEP_PROBE_NOT_APPROVED", "SEP_VALUE_IN_REQUEST", "SEP_GITIGNORE_UNSAFE", "SEP_CONFIRMATION_DENIED", "SEP_RATE_LIMITED", "SEP_TARGET_CHANGED", "SEP_PATTERN_UNSAFE", "SEP_KEYS_MISSING"];
 export type SepErrorCode = (typeof SEP_ERROR_CODES)[number];
 export interface SepErrorDefaults {
     retriable: boolean;

package/dist/errors.js

@@ -14,6 +14,8 @@ export const SEP_ERROR_CODES = [
     'SEP_CONFIRMATION_DENIED',
     'SEP_RATE_LIMITED',
     'SEP_TARGET_CHANGED',
+    'SEP_PATTERN_UNSAFE',
+    'SEP_KEYS_MISSING',
 ];
 export const SEP_ERROR_DEFAULTS = {
     SEP_UNKNOWN_KEY: {
@@ -77,6 +79,14 @@ export const SEP_ERROR_DEFAULTS = {
         userMessage: 'The program to run changed on disk after you approved it. Nothing was executed. ' +
             'Re-run the command to review the current content and approve it again.',
     },
+    SEP_PATTERN_UNSAFE: {
+        retriable: false,
+        userMessage: 'The declared format.pattern is unsafe or too complex. Use a shorter, bounded pattern (for example ^sk-[A-Za-z0-9]{20,80}$).',
+    },
+    SEP_KEYS_MISSING: {
+        retriable: false,
+        userMessage: 'One or more requested keys are undeclared or have no stored value. Declare and store them before use.',
+    },
 };
 export class SepError extends Error {
     code;

package/dist/schemas.d.ts

@@ -1,11 +1,15 @@
 import { z } from 'zod';
+export declare const FORMAT_PATTERN_MAX_LENGTH = 256;
+export declare const FORMAT_PATTERN_MAX_QUANTIFIER = 256;
+/** Safe subset check for manifest `format.pattern` (length, bounded quantifiers, no nested +/*). */
+export declare function isLinearishRegex(pattern: string): boolean;
 export declare const ManifestEntry: z.ZodEffects<z.ZodObject<{
     key: z.ZodString;
     description: z.ZodString;
     required: z.ZodDefault<z.ZodBoolean>;
     secret: z.ZodDefault<z.ZodBoolean>;
     format: z.ZodOptional<z.ZodObject<{
-        pattern: z.ZodOptional<z.ZodString>;
+        pattern: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
         minLength: z.ZodOptional<z.ZodNumber>;
         maxLength: z.ZodOptional<z.ZodNumber>;
         example: z.ZodOptional<z.ZodString>;
@@ -193,7 +197,7 @@ export declare const Manifest: z.ZodObject<{
         required: z.ZodDefault<z.ZodBoolean>;
         secret: z.ZodDefault<z.ZodBoolean>;
         format: z.ZodOptional<z.ZodObject<{
-            pattern: z.ZodOptional<z.ZodString>;
+            pattern: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
             minLength: z.ZodOptional<z.ZodNumber>;
             maxLength: z.ZodOptional<z.ZodNumber>;
             example: z.ZodOptional<z.ZodString>;
@@ -534,13 +538,13 @@ export declare const VerifyResult: z.ZodObject<{
     message: z.ZodString;
     checkedAt: z.ZodString;
 }, "strict", z.ZodTypeAny, {
-    key: string;
     message: string;
+    key: string;
     result: "ok" | "auth_failed" | "forbidden" | "rate_limited" | "network_error" | "no_probe" | "probe_not_approved";
     checkedAt: string;
 }, {
-    key: string;
     message: string;
+    key: string;
     result: "ok" | "auth_failed" | "forbidden" | "rate_limited" | "network_error" | "no_probe" | "probe_not_approved";
     checkedAt: string;
 }>;
@@ -699,7 +703,7 @@ export declare const EnvDeclareInput: z.ZodObject<{
         required: z.ZodDefault<z.ZodBoolean>;
         secret: z.ZodDefault<z.ZodBoolean>;
         format: z.ZodOptional<z.ZodObject<{
-            pattern: z.ZodOptional<z.ZodString>;
+            pattern: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
             minLength: z.ZodOptional<z.ZodNumber>;
             maxLength: z.ZodOptional<z.ZodNumber>;
             example: z.ZodOptional<z.ZodString>;
@@ -1005,7 +1009,7 @@ export declare const INPUT_SCHEMAS: {
             required: z.ZodDefault<z.ZodBoolean>;
             secret: z.ZodDefault<z.ZodBoolean>;
             format: z.ZodOptional<z.ZodObject<{
-                pattern: z.ZodOptional<z.ZodString>;
+                pattern: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
                 minLength: z.ZodOptional<z.ZodNumber>;
                 maxLength: z.ZodOptional<z.ZodNumber>;
                 example: z.ZodOptional<z.ZodString>;

package/dist/schemas.js

@@ -1,4 +1,201 @@
 import { z } from 'zod';
+export const FORMAT_PATTERN_MAX_LENGTH = 256;
+export const FORMAT_PATTERN_MAX_QUANTIFIER = 256;
+function isQuantifierBrace(pattern, index) {
+    return /^\{\d/.test(pattern.slice(index));
+}
+function parseQuantifier(pattern, start) {
+    const ch = pattern[start];
+    if (ch === '+' || ch === '*' || ch === '?') {
+        return { ok: true, end: start + 1 };
+    }
+    if (ch !== '{' || !isQuantifierBrace(pattern, start)) {
+        return { ok: true, end: start };
+    }
+    const close = pattern.indexOf('}', start + 1);
+    if (close === -1) {
+        return { ok: false };
+    }
+    const body = pattern.slice(start + 1, close);
+    const comma = body.indexOf(',');
+    let minStr;
+    let maxStr;
+    if (comma === -1) {
+        minStr = body;
+        maxStr = undefined;
+    }
+    else {
+        minStr = body.slice(0, comma);
+        maxStr = body.slice(comma + 1);
+    }
+    if (minStr !== '' && !/^\d+$/.test(minStr)) {
+        return { ok: false };
+    }
+    if (maxStr !== undefined && maxStr !== '' && !/^\d+$/.test(maxStr)) {
+        return { ok: false };
+    }
+    const min = minStr === '' ? 0 : Number(minStr);
+    const max = maxStr === undefined || maxStr === '' ? undefined : Number(maxStr);
+    if (!Number.isInteger(min) || min < 0) {
+        return { ok: false };
+    }
+    if (max !== undefined && (!Number.isInteger(max) || max < min)) {
+        return { ok: false };
+    }
+    if (min > FORMAT_PATTERN_MAX_QUANTIFIER) {
+        return { ok: false };
+    }
+    if (max === undefined && comma !== -1) {
+        return { ok: false };
+    }
+    if (max !== undefined && max > FORMAT_PATTERN_MAX_QUANTIFIER) {
+        return { ok: false };
+    }
+    return { ok: true, end: close + 1 };
+}
+function skipCharacterClass(pattern, start) {
+    let i = start + 1;
+    if (pattern[i] === '^') {
+        i++;
+    }
+    while (i < pattern.length) {
+        if (pattern[i] === '\\') {
+            i += 2;
+            continue;
+        }
+        if (pattern[i] === ']') {
+            return i + 1;
+        }
+        i++;
+    }
+    return null;
+}
+function skipGroupHeader(pattern, start) {
+    let i = start + 1;
+    if (pattern[i] !== '?') {
+        return i;
+    }
+    i++;
+    if (pattern[i] === ':') {
+        return i + 1;
+    }
+    if (pattern[i] === '<') {
+        i++;
+        if (pattern[i] === '=' || pattern[i] === '!') {
+            return i + 1;
+        }
+        return i;
+    }
+    if (pattern[i] === '=' || pattern[i] === '!') {
+        return i + 1;
+    }
+    while (i < pattern.length && /[a-z-]/.test(pattern[i])) {
+        i++;
+    }
+    if (pattern[i] === ':') {
+        return i + 1;
+    }
+    if (pattern[i] === ')') {
+        return i + 1;
+    }
+    return i;
+}
+function scanLinearishPattern(pattern) {
+    const groupHasInnerQuantifier = [];
+    const markInnerQuantifier = () => {
+        if (groupHasInnerQuantifier.length > 0) {
+            groupHasInnerQuantifier[groupHasInnerQuantifier.length - 1] = true;
+        }
+    };
+    const afterAtom = (start, innerQuantified) => {
+        const quantifier = parseQuantifier(pattern, start);
+        if (!quantifier.ok) {
+            return null;
+        }
+        if (quantifier.end > start) {
+            if (innerQuantified) {
+                return null;
+            }
+            markInnerQuantifier();
+        }
+        return quantifier.end;
+    };
+    let i = 0;
+    while (i < pattern.length) {
+        const ch = pattern[i];
+        if (ch === '\\') {
+            i += 2;
+            if (i > pattern.length) {
+                return false;
+            }
+            i = afterAtom(i, false) ?? -1;
+            if (i === -1) {
+                return false;
+            }
+            continue;
+        }
+        if (ch === '[') {
+            const end = skipCharacterClass(pattern, i);
+            if (end === null) {
+                return false;
+            }
+            const next = afterAtom(end, false);
+            if (next === null) {
+                return false;
+            }
+            i = next;
+            continue;
+        }
+        if (ch === '(') {
+            i = skipGroupHeader(pattern, i);
+            groupHasInnerQuantifier.push(false);
+            continue;
+        }
+        if (ch === ')') {
+            if (groupHasInnerQuantifier.length === 0) {
+                return false;
+            }
+            const innerQuantified = groupHasInnerQuantifier.pop();
+            i++;
+            const next = afterAtom(i, innerQuantified);
+            if (next === null) {
+                return false;
+            }
+            i = next;
+            continue;
+        }
+        if (ch === '^' || ch === '$' || ch === '|') {
+            i++;
+            continue;
+        }
+        i++;
+        const next = afterAtom(i, false);
+        if (next === null) {
+            return false;
+        }
+        i = next;
+    }
+    return groupHasInnerQuantifier.length === 0;
+}
+/** Safe subset check for manifest `format.pattern` (length, bounded quantifiers, no nested +/*). */
+export function isLinearishRegex(pattern) {
+    if (pattern.length > FORMAT_PATTERN_MAX_LENGTH) {
+        return false;
+    }
+    try {
+        new RegExp(pattern);
+    }
+    catch {
+        return false;
+    }
+    return scanLinearishPattern(pattern);
+}
+const formatPatternSchema = z
+    .string()
+    .max(FORMAT_PATTERN_MAX_LENGTH)
+    .refine(isLinearishRegex, {
+    message: 'format.pattern must be a safe, bounded regular expression',
+});
 export const ManifestEntry = z
     .object({
     key: z.string().regex(/^[A-Z][A-Z0-9_]{0,63}$/),
@@ -7,7 +204,7 @@ export const ManifestEntry = z
     secret: z.boolean().default(true),
     format: z
         .object({
-        pattern: z.string().optional(),
+        pattern: formatPatternSchema.optional(),
         minLength: z.number().int().optional(),
         maxLength: z.number().int().optional(),
         example: z.string().optional(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@envseal/protocol",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "type": "module",
   "license": "Apache-2.0",
   "main": "./dist/index.js",