citadel0 1.0.0 → 1.0.1

package/dist/index.cjs

@@ -20,237 +20,22 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  CitadelClient: () => CitadelClient,
+  Citadel_0: () => Citadel_0,
   evaluatePolicies: () => evaluatePolicies,
-  scanPayloadSemantics: () => scanPayloadSemantics,
-  wrapTool: () => wrapTool,
-  wrapToolWithReview: () => wrapToolWithReview
+  guardTool: () => guardTool
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/sdk/client.ts
-var CitadelClient = class {
-  baseUrl;
-  agentToken;
-  environment;
-  defaultSessionId;
-  constructor(config) {
-    this.baseUrl = config.baseUrl.replace(/\/+$/, "");
-    this.agentToken = config.agentToken;
-    this.environment = config.environment;
-    this.defaultSessionId = config.defaultSessionId;
-  }
-  async check(action, params = {}, options = {}) {
-    const url = `${this.baseUrl}/api/v1/check`;
-    const sessionId = options.sessionId ?? this.defaultSessionId ?? `sess_${Math.random().toString(36).slice(2, 11)}`;
-    const response = await fetch(url, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${this.agentToken}`
-      },
-      body: JSON.stringify({
-        action,
-        params,
-        sessionId,
-        environment: options.environment ?? this.environment,
-        metadata: options.metadata
-      })
-    });
-    if (!response.ok) {
-      const errorBody = await response.json().catch(() => ({}));
-      const errorMessage = typeof errorBody.error === "string" ? errorBody.error : `Citadel gateway error: ${response.status} ${response.statusText}`;
-      throw new Error(errorMessage);
-    }
-    return await response.json();
-  }
-  async isAllowed(action, params = {}, options = {}) {
-    const result = await this.check(action, params, options);
-    return result.verdict.decision === "ALLOW";
-  }
-  async guard(action, params, callback, options = {}) {
-    const result = await this.check(action, params, options);
-    if (result.verdict.decision !== "ALLOW") {
-      throw new Error(
-        `Action '${action}' blocked by Citadel: ${result.verdict.reason}`
-      );
-    }
-    return await callback();
-  }
-  async getReviewStatus(auditLogId) {
-    const url = `${this.baseUrl}/api/v1/review/status?auditLogId=${encodeURIComponent(
-      auditLogId
-    )}`;
-    const response = await fetch(url);
-    if (!response.ok) {
-      const errorBody = await response.json().catch(() => ({}));
-      const errorMessage = typeof errorBody.error === "string" ? errorBody.error : `Review status error: ${response.status}`;
-      throw new Error(errorMessage);
-    }
-    return await response.json();
-  }
-  async pollReview(auditLogId, options = {}) {
-    const timeoutMs = options.timeoutMs ?? 6e4;
-    const intervalMs = options.intervalMs ?? 2e3;
-    const deadline = Date.now() + timeoutMs;
-    while (Date.now() < deadline) {
-      const status = await this.getReviewStatus(auditLogId);
-      if (status.decision !== "REVIEW") {
-        return status;
-      }
-      await new Promise((resolve) => setTimeout(resolve, intervalMs));
-    }
-    throw new Error(
-      `Review timed out after ${timeoutMs}ms for auditLogId: ${auditLogId}`
-    );
-  }
-  async guardWithReview(action, params, callback, options = {}) {
-    const result = await this.check(action, params, options);
-    if (result.verdict.decision === "ALLOW") {
-      return await callback();
-    }
-    if (result.verdict.decision === "BLOCK") {
-      throw new Error(
-        `Action '${action}' blocked by Citadel: ${result.verdict.reason}`
-      );
-    }
-    if (options.onReviewPending) {
-      options.onReviewPending(result.auditLogId);
-    }
-    const reviewed = await this.pollReview(result.auditLogId, {
-      timeoutMs: options.timeoutMs,
-      intervalMs: options.pollIntervalMs
-    });
-    if (reviewed.decision === "ALLOW") {
-      return await callback();
-    }
-    throw new Error(
-      `Action '${action}' rejected during human review: ${reviewed.reviewComment ?? "Rejected"}`
-    );
-  }
-};
-
-// src/sdk/tools.ts
-function wrapTool(client, tool) {
-  return {
-    ...tool,
-    execute: async (args) => {
-      return await client.guard(
-        tool.name,
-        args,
-        () => tool.execute(args),
-        tool.options
-      );
-    }
-  };
-}
-function wrapToolWithReview(client, tool, reviewOptions) {
-  return {
-    ...tool,
-    execute: async (args) => {
-      return await client.guardWithReview(
-        tool.name,
-        args,
-        () => tool.execute(args),
-        {
-          ...tool.options,
-          ...reviewOptions
-        }
-      );
-    }
-  };
-}
-
-// src/engine/semantic.ts
-var INJECTION_PATTERNS = [
-  {
-    regex: /(?:ignore|disregard|forget|bypass|override)\s+(?:all\s+)?(?:previous|prior|existing|above)\s+(?:instructions|rules|guidelines|directions|constraints)/i,
-    description: "Direct prompt instruction override",
-    score: 95
-  },
-  {
-    regex: /(?:you\s+are\s+now|act\s+as|roleplay\s+as)\s+(?:an?\s+)?(?:unfiltered|unrestricted|jailbroken|evil|dan|developer\s+mode)/i,
-    description: "Adversarial persona / DAN jailbreak attempt",
-    score: 90
-  },
-  {
-    regex: /(?:reveal|output|print|display|leak)\s+(?:the\s+)?(?:system\s+prompt|initial\s+prompt|core\s+instructions|developer\s+instructions)/i,
-    description: "System prompt extraction attempt",
-    score: 85
-  },
-  {
-    regex: /(?:\[INST\]|\[\/INST\]|<<SYS>>|<\/SYS>|<\|im_start\|>|<\|im_end\|>)/i,
-    description: "Model token delimiter injection",
-    score: 90
-  }
-];
-var CREDENTIAL_PATTERNS = [
-  {
-    regex: /(?:sk-[a-zA-Z0-9-_]{20,}|ghp_[a-zA-Z0-9]{36}|gho_[a-zA-Z0-9]{36})/i,
-    description: "Exposed API token (OpenAI / GitHub)",
-    score: 95
-  },
-  {
-    regex: /AKIA[0-9A-Z]{16}/,
-    description: "AWS Access Key ID",
-    score: 90
-  },
-  {
-    regex: /-----BEGIN (?:RSA |EC |DSA |OPENSSH )?PRIVATE KEY-----/,
-    description: "Exposed Private Key block",
-    score: 99
-  }
-];
-function extractStrings(obj) {
-  const strings = [];
-  function recurse(value) {
-    if (typeof value === "string") {
-      strings.push(value);
-    } else if (Array.isArray(value)) {
-      for (const item of value) recurse(item);
-    } else if (value !== null && typeof value === "object") {
-      for (const val of Object.values(value)) {
-        recurse(val);
-      }
-    }
-  }
-  recurse(obj);
-  return strings;
-}
-function scanPayloadSemantics(params) {
-  const stringsToScan = extractStrings(params);
-  const threats = [];
-  for (const text of stringsToScan) {
-    for (const rule of INJECTION_PATTERNS) {
-      if (rule.regex.test(text)) {
-        threats.push({
-          type: "PROMPT_INJECTION",
-          confidence: rule.score / 100,
-          reason: rule.description,
-          matchedPattern: rule.regex.source
-        });
-      }
-    }
-    for (const rule of CREDENTIAL_PATTERNS) {
-      if (rule.regex.test(text)) {
-        threats.push({
-          type: "CREDENTIAL_LEAK",
-          confidence: rule.score / 100,
-          reason: rule.description,
-          matchedPattern: rule.regex.source
-        });
-      }
-    }
+// src/engine/match.ts
+var regexCache = /* @__PURE__ */ new Map();
+function getCompiledRegex(pattern) {
+  let re = regexCache.get(pattern);
+  if (!re) {
+    re = new RegExp(pattern);
+    regexCache.set(pattern, re);
   }
-  const maxScore = threats.length > 0 ? Math.max(...threats.map((t) => t.confidence * 100)) : 0;
-  return {
-    flagged: threats.length > 0,
-    threats,
-    maxRiskScore: Math.round(maxScore)
-  };
+  return re;
 }
-
-// src/engine/match.ts
 function extractField(obj, path) {
   const parts = path.split(".");
   let current = obj;
@@ -292,7 +77,7 @@ function evaluateCondition(actual, operator, target) {
         return false;
       }
       try {
-        return new RegExp(target).test(actual);
+        return getCompiledRegex(target).test(actual);
       } catch {
         return false;
       }
@@ -305,8 +90,7 @@ function matchesActionPattern(pattern, action) {
     return true;
   }
   if (pattern.endsWith("*")) {
-    const prefix = pattern.slice(0, -1);
-    return action.startsWith(prefix);
+    return action.startsWith(pattern.slice(0, -1));
   }
   return false;
 }
@@ -314,37 +98,35 @@ function evaluateRule(payload, rule) {
   const targetObject = {
     action: payload.action,
     params: payload.params,
-    context: payload.context,
-    timestamp: payload.timestamp,
+    context: payload.context ?? {},
     metadata: payload.metadata ?? {}
   };
   const actualValue = extractField(targetObject, rule.field);
   return evaluateCondition(actualValue, rule.operator, rule.value);
 }
-function calculateRisk(decision, matchedCount, semanticScore = 0) {
+function calculateRisk(decision, matchedCount) {
   if (decision === "BLOCK") {
-    return { riskScore: Math.max(95, semanticScore), riskLevel: "CRITICAL" };
+    return { riskScore: 95, riskLevel: "CRITICAL" };
   }
   if (decision === "REVIEW") {
-    return { riskScore: Math.max(65, semanticScore), riskLevel: "HIGH" };
+    return { riskScore: 65, riskLevel: "HIGH" };
   }
   if (matchedCount > 0) {
     return { riskScore: 25, riskLevel: "MEDIUM" };
   }
   return { riskScore: 5, riskLevel: "LOW" };
 }
-function evaluatePolicies(payload, policies) {
-  const startTime = Date.now();
+function evaluatePolicies(payload, sortedPolicies) {
+  const startTime = performance.now();
   const traces = [];
-  const activePolicies = policies.filter((p) => p.isActive && p.tenantId === payload.context.tenantId).sort((a, b) => b.priority - a.priority);
   let finalDecision = "ALLOW";
-  let primaryReason = "No blocking or review policies triggered";
-  let pipeline = "DETERMINISTIC";
-  for (const policy of activePolicies) {
-    if (!matchesActionPattern(policy.actionPattern, payload.action)) {
+  let primaryReason = "All security policies satisfied";
+  for (let i = 0; i < sortedPolicies.length; i++) {
+    const policy = sortedPolicies[i];
+    if (!policy.isActive || !matchesActionPattern(policy.actionPattern, payload.action)) {
       continue;
     }
-    const rulesMatched = policy.rules.length > 0 && policy.rules.every((rule) => evaluateRule(payload, rule));
+    const rulesMatched = policy.rules.length === 0 || policy.rules.every((rule) => evaluateRule(payload, rule));
     if (rulesMatched) {
       traces.push({
         policyId: policy.id,
@@ -363,36 +145,139 @@ function evaluatePolicies(payload, policies) {
       }
     }
   }
-  let semanticScore = 0;
-  if (finalDecision !== "BLOCK") {
-    const semanticResult = scanPayloadSemantics(payload.params);
-    if (semanticResult.flagged) {
-      pipeline = traces.length > 0 ? "HYBRID" : "AI_GUARD";
-      semanticScore = semanticResult.maxRiskScore;
-      finalDecision = "BLOCK";
-      const threatReasons = semanticResult.threats.map((t) => t.reason).join(", ");
-      primaryReason = `AI Guard blocked threat: ${threatReasons}`;
-    }
-  }
-  const { riskScore, riskLevel } = calculateRisk(finalDecision, traces.length, semanticScore);
-  const latencyMs = Date.now() - startTime;
+  const { riskScore, riskLevel } = calculateRisk(finalDecision, traces.length);
+  const latencyMs = Number((performance.now() - startTime).toFixed(3));
   return {
     verdictId: `vrd_${Math.random().toString(36).slice(2, 11)}`,
     decision: finalDecision,
     reason: primaryReason,
     riskScore,
     riskLevel,
-    evaluationPipeline: pipeline,
     matchedPolicies: traces,
-    executedAt: startTime,
+    executedAt: Date.now(),
     latencyMs
   };
 }
+
+// src/sdk/client.ts
+var Citadel_0 = class {
+  baseUrl;
+  agentToken;
+  environment;
+  defaultSessionId;
+  policies = [];
+  telemetryQueue = [];
+  batchSize;
+  flushTimer = null;
+  constructor(config) {
+    this.baseUrl = config.baseUrl.replace(/\/+$/, "");
+    this.agentToken = config.agentToken;
+    this.environment = config.environment ?? "production";
+    this.defaultSessionId = config.defaultSessionId;
+    this.batchSize = config.batchSize ?? 50;
+    if (config.policies) {
+      this.setPolicies(config.policies);
+    }
+    const interval = config.flushIntervalMs ?? 3e3;
+    this.flushTimer = setInterval(() => {
+      void this.flush();
+    }, interval);
+    if (typeof this.flushTimer === "object" && "unref" in this.flushTimer) {
+      this.flushTimer.unref();
+    }
+  }
+  setPolicies(policies) {
+    this.policies = [...policies].sort((a, b) => b.priority - a.priority);
+  }
+  async syncPolicies() {
+    const res = await fetch(`${this.baseUrl}/api/v1/policies`, {
+      headers: { Authorization: `Bearer ${this.agentToken}` }
+    });
+    if (res.ok) {
+      const data = await res.json();
+      const list = Array.isArray(data) ? data : data?.policies ?? [];
+      this.setPolicies(list);
+    }
+  }
+  check(action, params = {}, options = {}) {
+    const payload = {
+      action,
+      params,
+      context: {
+        sessionId: options.sessionId ?? this.defaultSessionId,
+        environment: options.environment ?? this.environment
+      },
+      metadata: options.metadata
+    };
+    const verdict = evaluatePolicies(payload, this.policies);
+    this.telemetryQueue.push({
+      traceId: verdict.verdictId,
+      action,
+      params,
+      verdict,
+      sessionId: payload.context?.sessionId,
+      environment: payload.context?.environment ?? this.environment,
+      timestamp: verdict.executedAt
+    });
+    if (this.telemetryQueue.length >= this.batchSize) {
+      void this.flush();
+    }
+    return verdict;
+  }
+  isAllowed(action, params = {}, options = {}) {
+    return this.check(action, params, options).decision === "ALLOW";
+  }
+  guard(action, params, callback, options = {}) {
+    const verdict = this.check(action, params, options);
+    if (verdict.decision === "BLOCK") {
+      throw new Error(`Action '${action}' blocked by Citadel 0: ${verdict.reason}`);
+    }
+    if (verdict.decision === "REVIEW") {
+      throw new Error(`Action '${action}' halted: requires human review`);
+    }
+    return callback();
+  }
+  async flush() {
+    if (this.telemetryQueue.length === 0) {
+      return;
+    }
+    const batch = this.telemetryQueue.splice(0, this.batchSize);
+    try {
+      await fetch(`${this.baseUrl}/api/v1/telemetry`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.agentToken}`
+        },
+        body: JSON.stringify({ traces: batch })
+      });
+    } catch {
+      this.telemetryQueue.unshift(...batch);
+    }
+  }
+  destroy() {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+    void this.flush();
+  }
+};
+
+// src/sdk/tools.ts
+function guardTool(client, action, fn, options) {
+  return async (args) => {
+    return client.guard(
+      action,
+      args,
+      () => fn(args),
+      options
+    );
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  CitadelClient,
+  Citadel_0,
   evaluatePolicies,
-  scanPayloadSemantics,
-  wrapTool,
-  wrapToolWithReview
+  guardTool
 });

package/dist/index.d.cts

@@ -1,20 +1,5 @@
 type Decision = 'ALLOW' | 'BLOCK' | 'REVIEW';
 type RiskLevel = 'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL';
-type PolicyEffect = 'ALLOW' | 'BLOCK' | 'REVIEW';
-interface SecurityContext {
-    tenantId: string;
-    agentId: string;
-    sessionId: string;
-    environment: 'production' | 'staging' | 'development';
-    clientIp?: string;
-}
-interface ActionPayload {
-    context: SecurityContext;
-    action: string;
-    params: Record<string, unknown>;
-    timestamp: number;
-    metadata?: Record<string, unknown>;
-}
 type PolicyConditionOperator = 'EQUALS' | 'NOT_EQUALS' | 'GREATER_THAN' | 'LESS_THAN' | 'IN' | 'NOT_IN' | 'CONTAINS' | 'REGEX_MATCH';
 interface PolicyRule {
     field: string;
@@ -23,20 +8,28 @@ interface PolicyRule {
 }
 interface SecurityPolicy {
     id: string;
-    tenantId: string;
     name: string;
-    description?: string;
     actionPattern: string;
-    rules: PolicyRule[];
-    effect: PolicyEffect;
+    effect: Decision;
     priority: number;
     isActive: boolean;
+    rules: PolicyRule[];
+}
+interface ActionPayload {
+    action: string;
+    params: Record<string, unknown>;
+    context?: {
+        tenantId?: string;
+        sessionId?: string;
+        environment?: string;
+    };
+    metadata?: Record<string, unknown>;
 }
 interface PolicyEvaluationTrace {
     policyId: string;
     policyName: string;
     matched: boolean;
-    effect: PolicyEffect;
+    effect: Decision;
 }
 interface SecurityVerdict {
     verdictId: string;
@@ -44,108 +37,58 @@ interface SecurityVerdict {
     reason: string;
     riskScore: number;
     riskLevel: RiskLevel;
-    evaluationPipeline: 'DETERMINISTIC' | 'AI_GUARD' | 'HYBRID';
     matchedPolicies: PolicyEvaluationTrace[];
     executedAt: number;
     latencyMs: number;
 }
-interface AuditLogEntry {
-    id: string;
-    tenantId: string;
-    agentId: string;
-    sessionId: string;
+interface TelemetryTrace {
+    traceId: string;
     action: string;
     params: Record<string, unknown>;
     verdict: SecurityVerdict;
-    reviewedBy?: string;
-    reviewComment?: string;
-    createdAt: number;
+    sessionId?: string;
+    environment: string;
+    timestamp: number;
 }
 
-interface CitadelClientConfig {
+declare function evaluatePolicies(payload: ActionPayload, sortedPolicies: SecurityPolicy[]): SecurityVerdict;
+
+interface Citadel_0_Config {
     baseUrl: string;
     agentToken: string;
     environment?: 'production' | 'staging' | 'development';
     defaultSessionId?: string;
+    policies?: SecurityPolicy[];
+    flushIntervalMs?: number;
+    batchSize?: number;
 }
 interface CheckOptions {
     sessionId?: string;
     environment?: 'production' | 'staging' | 'development';
     metadata?: Record<string, unknown>;
 }
-interface CheckResult {
-    verdict: SecurityVerdict;
-    auditLogId: string;
-}
-interface ReviewStatus {
-    auditLogId: string;
-    decision: 'ALLOW' | 'BLOCK' | 'REVIEW';
-    reviewedBy?: string;
-    reviewComment?: string;
-    action: string;
-    params: unknown;
-    riskScore: number;
-    riskLevel: string;
-    createdAt: number;
-}
-interface GuardWithReviewOptions extends CheckOptions {
-    timeoutMs?: number;
-    pollIntervalMs?: number;
-    onReviewPending?: (auditLogId: string) => void;
-}
-declare class CitadelClient {
+declare class Citadel_0 {
     private readonly baseUrl;
     private readonly agentToken;
-    private readonly environment?;
+    private readonly environment;
     private readonly defaultSessionId?;
-    constructor(config: CitadelClientConfig);
-    check(action: string, params?: Record<string, unknown>, options?: CheckOptions): Promise<CheckResult>;
-    isAllowed(action: string, params?: Record<string, unknown>, options?: CheckOptions): Promise<boolean>;
-    guard<T>(action: string, params: Record<string, unknown>, callback: () => Promise<T> | T, options?: CheckOptions): Promise<T>;
-    getReviewStatus(auditLogId: string): Promise<ReviewStatus>;
-    pollReview(auditLogId: string, options?: {
-        timeoutMs?: number;
-        intervalMs?: number;
-    }): Promise<ReviewStatus>;
-    guardWithReview<T>(action: string, params: Record<string, unknown>, callback: () => Promise<T> | T, options?: GuardWithReviewOptions): Promise<T>;
+    private policies;
+    private telemetryQueue;
+    private readonly batchSize;
+    private flushTimer;
+    constructor(config: Citadel_0_Config);
+    setPolicies(policies: SecurityPolicy[]): void;
+    syncPolicies(): Promise<void>;
+    check(action: string, params?: Record<string, unknown>, options?: CheckOptions): SecurityVerdict;
+    isAllowed(action: string, params?: Record<string, unknown>, options?: CheckOptions): boolean;
+    guard<T>(action: string, params: Record<string, unknown>, callback: () => Promise<T> | T, options?: CheckOptions): Promise<T> | T;
+    flush(): Promise<void>;
+    destroy(): void;
 }
 
-interface GuardedToolDefinition<TArgs = any, TResult = any> {
-    name: string;
-    description?: string;
-    execute: (args: TArgs) => Promise<TResult> | TResult;
-    options?: CheckOptions;
-}
-declare function wrapTool<TArgs extends Record<string, unknown>, TResult>(client: CitadelClient, tool: GuardedToolDefinition<TArgs, TResult>): {
-    execute: (args: TArgs) => Promise<TResult>;
-    name: string;
-    description?: string;
-    options?: CheckOptions;
-};
-declare function wrapToolWithReview<TArgs extends Record<string, unknown>, TResult>(client: CitadelClient, tool: GuardedToolDefinition<TArgs, TResult>, reviewOptions?: {
-    timeoutMs?: number;
-    pollIntervalMs?: number;
-    onReviewPending?: (auditLogId: string) => void;
-}): {
-    execute: (args: TArgs) => Promise<TResult>;
-    name: string;
-    description?: string;
-    options?: CheckOptions;
-};
-
-interface ThreatDetection {
-    type: 'PROMPT_INJECTION' | 'JAILBREAK_ATTEMPT' | 'CREDENTIAL_LEAK';
-    confidence: number;
-    reason: string;
-    matchedPattern: string;
+interface GuardedToolOptions extends CheckOptions {
+    actionName?: string;
 }
-interface SemanticScanResult {
-    flagged: boolean;
-    threats: ThreatDetection[];
-    maxRiskScore: number;
-}
-declare function scanPayloadSemantics(params: Record<string, unknown>): SemanticScanResult;
-
-declare function evaluatePolicies(payload: ActionPayload, policies: SecurityPolicy[]): SecurityVerdict;
+declare function guardTool<TArgs extends Record<string, unknown>, TResult>(client: Citadel_0, action: string, fn: (args: TArgs) => Promise<TResult> | TResult, options?: CheckOptions): (args: TArgs) => Promise<TResult>;
 
-export { type ActionPayload, type AuditLogEntry, type CheckOptions, type CheckResult, CitadelClient, type CitadelClientConfig, type Decision, type GuardWithReviewOptions, type GuardedToolDefinition, type PolicyConditionOperator, type PolicyEffect, type PolicyEvaluationTrace, type PolicyRule, type ReviewStatus, type RiskLevel, type SecurityContext, type SecurityPolicy, type SecurityVerdict, type SemanticScanResult, type ThreatDetection, evaluatePolicies, scanPayloadSemantics, wrapTool, wrapToolWithReview };
+export { type ActionPayload, type CheckOptions, Citadel_0, type Citadel_0_Config, type Decision, type GuardedToolOptions, type PolicyConditionOperator, type PolicyEvaluationTrace, type PolicyRule, type RiskLevel, type SecurityPolicy, type SecurityVerdict, type TelemetryTrace, evaluatePolicies, guardTool };