@highflame/policy 2.0.6 → 2.0.8

package/src/parser.ts

@@ -119,7 +119,14 @@ export function parseCedarToRules(cedarText: string): ParseResult {
 
       const policy = jsonResult.json as CedarPolicyJSON;
       const policyId = policy.annotations?.id || `policy${index}`;
-      const conversion = cedarJsonToRule(policy, policyId, index, policyText);
+
+      // Get engine-serialized Cedar text for rawCondition extraction.
+      // Using cedar-wasm's policyToText ensures we get the official engine's
+      // representation rather than relying on our own text extraction.
+      const engineTextResult = cedar.policyToText(jsonResult.json);
+      const engineText = engineTextResult.type === "success" ? engineTextResult.text : policyText;
+
+      const conversion = cedarJsonToRule(policy, policyId, index, engineText);
 
       if (conversion.error) {
         result.errors.push(`Policy ${policyId}: ${conversion.error}`);
@@ -207,7 +214,7 @@ function cedarJsonToRule(
     };
 
     // Map conditions
-    const { conditions, rawCondition } = mapConditions(policy.conditions);
+    const { conditions, rawCondition } = mapConditions(policy.conditions, originalText);
     rule.conditions = conditions;
     if (rawCondition) {
       rule.rawCondition = rawCondition;
@@ -325,6 +332,20 @@ function mapScopeToEntity(scope: CedarScopeConstraint, field: string): PolicyEnt
  *
  * Throws ParserError for malformed constraints to prevent silent misinterpretation.
  */
+/**
+ * Format action entity reference, preserving namespace if present.
+ *
+ * If entity type is just "Action", returns just the id (e.g., "process_prompt").
+ * If entity type has a namespace (e.g., "Overwatch::Action"),
+ * returns the fully qualified action string (e.g., 'Overwatch::Action::"process_prompt"').
+ */
+function formatActionEntity(entity: { type: string; id: string }): string {
+  if (entity.type !== "Action") {
+    return `${entity.type}::"${entity.id}"`;
+  }
+  return entity.id;
+}
+
 function mapActionScope(scope: CedarActionConstraint): string | string[] {
   if (scope.op === "All") {
     return "*";
@@ -333,19 +354,19 @@ function mapActionScope(scope: CedarActionConstraint): string | string[] {
   if (scope.op === "==") {
     if ("entity" in scope) {
       const entity = normalizeEntityRef(scope.entity);
-      return entity.id;
+      return formatActionEntity(entity);
     }
     throw ParserError.actionMissingEntity("==");
   }
 
   if (scope.op === "in") {
     if ("entities" in scope) {
-      const actions = scope.entities.map(e => normalizeEntityRef(e).id);
+      const actions = scope.entities.map(e => formatActionEntity(normalizeEntityRef(e)));
       return actions.length === 1 ? actions[0] : actions;
     }
     if ("entity" in scope) {
       const entity = normalizeEntityRef(scope.entity);
-      return entity.id;
+      return formatActionEntity(entity);
     }
     throw ParserError.actionMissingEntities();
   }
@@ -354,14 +375,16 @@ function mapActionScope(scope: CedarActionConstraint): string | string[] {
 }
 
 /**
- * Map Cedar conditions to PolicyCondition array
+ * Map Cedar conditions to PolicyCondition array.
+ * When conditions can't be mapped to structured format, extract the raw Cedar
+ * condition text from the engine-serialized policy text (not JSON AST).
  */
-function mapConditions(conditions: CedarCondition[]): {
+function mapConditions(conditions: CedarCondition[], originalText?: string): {
   conditions: PolicyCondition[];
   rawCondition?: string;
 } {
   const result: PolicyCondition[] = [];
-  const rawParts: string[] = [];
+  let hasUnmapped = false;
 
   for (const cond of conditions) {
     if (cond.kind !== "when") {
@@ -372,18 +395,49 @@ function mapConditions(conditions: CedarCondition[]): {
     if (parsed.condition) {
       result.push(parsed.condition);
     } else if (parsed.raw) {
-      rawParts.push(parsed.raw);
+      hasUnmapped = true;
     }
   }
 
-  // Store raw conditions as a valid JSON array instead of joining with " && "
-  // This ensures downstream systems can parse the rawCondition field
+  // Extract readable Cedar condition text instead of storing JSON AST
+  let rawCondition: string | undefined;
+  if (hasUnmapped && originalText) {
+    rawCondition = extractWhenClause(originalText);
+  }
+
   return {
     conditions: result,
-    rawCondition: rawParts.length > 0 ? `[${rawParts.join(",")}]` : undefined,
+    rawCondition: rawCondition || undefined,
   };
 }
 
+/**
+ * Extract the readable condition text from a Cedar policy's when clause.
+ * Given: `forbid (...)\nwhen { context.path like "/etc/*" };`
+ * Returns: `context.path like "/etc/*"`
+ */
+function extractWhenClause(cedarText: string): string {
+  const whenPrefix = "when {";
+  const idx = cedarText.indexOf(whenPrefix);
+  if (idx < 0) {
+    return "";
+  }
+
+  const body = cedarText.substring(idx + whenPrefix.length);
+  let depth = 1;
+  for (let i = 0; i < body.length; i++) {
+    if (body[i] === "{") depth++;
+    if (body[i] === "}") {
+      depth--;
+      if (depth === 0) {
+        return body.substring(0, i).trim();
+      }
+    }
+  }
+
+  return body.trim();
+}
+
 /**
  * Cedar expression types (subset used for condition mapping)
  */

package/src/schemas.test.ts

@@ -216,6 +216,22 @@ describe('Service-Specific Schemas', () => {
           max_threat_severity: 1,
           contains_secrets: false,
           response_content: '',
+          // Trust/Safety scores
+          violence_score: 0,
+          weapons_score: 0,
+          hate_speech_score: 0,
+          crime_score: 0,
+          sexual_score: 0,
+          profanity_score: 0,
+          // Detector confidence
+          pii_confidence: 0,
+          injection_confidence: 0,
+          jailbreak_confidence: 0,
+          // Agent security
+          tool_poisoning_score: 0,
+          rug_pull_score: 0,
+          indirect_injection_score: 0,
+          mcp_server_verified: false,
         },
         entities,
       });
@@ -397,6 +413,22 @@ describe('Service-Specific Schemas', () => {
           max_threat_severity: 2,
           contains_secrets: false,
           response_content: '',
+          // Trust/Safety scores
+          violence_score: 0,
+          weapons_score: 0,
+          hate_speech_score: 0,
+          crime_score: 0,
+          sexual_score: 0,
+          profanity_score: 0,
+          // Detector confidence
+          pii_confidence: 0,
+          injection_confidence: 0,
+          jailbreak_confidence: 0,
+          // Agent security
+          tool_poisoning_score: 0,
+          rug_pull_score: 0,
+          indirect_injection_score: 0,
+          mcp_server_verified: false,
         },
         entities,
       });