@secureai-sdk/sdk 1.2.0

package/src/grok-bot.ts

@@ -0,0 +1,129 @@
+import { BotIngressResult, BotToolResult, BotEgressResult } from "./types";
+import { inspectInput } from "./guard";
+
+const CLEARANCE_RULES: Record<number, RegExp[]> = {
+  1: [/^read_/i, /^search_/i, /^get_/i, /^lookup_/i, /^query_/i, /^fetch_/i],
+  2: [/^post_tweet/i, /^reply_/i, /^send_dm/i, /^discord_reply/i, /^like_/i, /^retweet/i],
+  3: [/^update_crm/i, /^create_ticket/i, /^send_email/i, /^charge_card/i, /^refund_/i],
+  4: [/^deploy_/i, /^restart_/i, /^migrate_db/i, /^write_config/i, /^modify_user/i],
+  5: [/^exec_bash/i, /^run_shell/i, /^system_/i, /^eval_/i, /^rm_/i, /^drop_table/i]
+};
+
+const SECRET_PATTERNS = [
+  { regex: /\b(?:sk-[a-zA-Z0-9]{20,})\b/g, label: "[REDACTED_OPENAI_KEY]" },
+  { regex: /\b(?:sec_live_[a-zA-Z0-9]{16,})\b/g, label: "[REDACTED_SECUREAI_KEY]" },
+  { regex: /\b(?:ghp_[a-zA-Z0-9]{36,})\b/g, label: "[REDACTED_GITHUB_PAT]" },
+  { regex: /\b(?:AKIA[0-9A-Z]{16})\b/g, label: "[REDACTED_AWS_KEY]" },
+  { regex: /\b(?:Bearer\s+[a-zA-Z0-9\-._~+/]+=*)\b/gi, label: "[REDACTED_BEARER_TOKEN]" },
+  { regex: /\b(?:postgres(?:ql)?:\/\/[^\s"']+)\b/gi, label: "[REDACTED_DATABASE_URL]" }
+];
+
+export interface GrokBotOptions {
+  botId?: string;
+  clearanceLevel?: number;
+  apiKey?: string;
+  blockOnIngressInjection?: boolean;
+}
+
+export class GrokBotGuard {
+  public botId: string;
+  public clearanceLevel: number;
+  public apiKey?: string;
+  public blockOnIngressInjection: boolean;
+
+  constructor(options: GrokBotOptions = {}) {
+    this.botId = options.botId || "grok_bot";
+    this.clearanceLevel = options.clearanceLevel || 2;
+    this.apiKey = options.apiKey || process.env.SECUREAI_API_KEY;
+    this.blockOnIngressInjection = options.blockOnIngressInjection ?? true;
+
+    if (!this.apiKey) {
+      throw new Error(
+        `SecureAI Authentication Required for Bot '${this.botId}': No API key provided. ` +
+        `Pass apiKey or set SECUREAI_API_KEY environment variable. ` +
+        `Create a key at https://secure.acadmyai.com/console/apikeys`
+      );
+    }
+  }
+
+  /**
+   * Stage 1: Pre-execution inspection & sanitization of untrusted public mentions or tweets.
+   */
+  public sanitizeMention(untrustedText: string): BotIngressResult {
+    const inspection = inspectInput(untrustedText);
+    return {
+      isSafe: inspection.isSafe,
+      sanitizedText: inspection.sanitizedText,
+      threatDetected: inspection.threatDetected,
+      riskScore: inspection.riskScore,
+      latencyMs: inspection.latencyMs,
+      matchedPatterns: inspection.matchedPatterns
+    };
+  }
+
+  /**
+   * Stage 2: Tool Action RBAC Firewall evaluating bot clearance levels.
+   * Returns synthetic error guidance on clearance denial to enable graceful model self-correction.
+   */
+  public interceptTool(toolName: string, params: Record<string, any> = {}): BotToolResult {
+    let requiredClearance = 3;
+    for (let level = 1; level <= 5; level++) {
+      const patterns = CLEARANCE_RULES[level] || [];
+      if (patterns.some((p) => p.test(toolName))) {
+        requiredClearance = level;
+        break;
+      }
+    }
+
+    if (requiredClearance > this.clearanceLevel) {
+      const syntheticError =
+        `[SecureAI Policy Clearance Denied]: Tool '${toolName}' requires Clearance Level ${requiredClearance}, ` +
+        `but bot '${this.botId}' operates at Level ${this.clearanceLevel}. ` +
+        `Action aborted. Please apologize to the user and explain that you do not have permission to execute this operation.`;
+
+      return {
+        allowed: false,
+        toolName,
+        requiredClearance,
+        botClearance: this.clearanceLevel,
+        syntheticError,
+        reason: `Clearance level ${this.clearanceLevel} insufficient for level ${requiredClearance} tool '${toolName}'`
+      };
+    }
+
+    return {
+      allowed: true,
+      toolName,
+      requiredClearance,
+      botClearance: this.clearanceLevel
+    };
+  }
+
+  /**
+   * Stage 3: Outbound Egress DLP preventing credential leaks and exfiltration before tweet publication.
+   */
+  public sanitizeEgress(botResponseText: string): BotEgressResult {
+    const start = performance.now();
+    let sanitized = botResponseText;
+    let leaksRedacted = 0;
+    const redactedTypes: string[] = [];
+
+    for (const { regex, label } of SECRET_PATTERNS) {
+      if (regex.test(sanitized)) {
+        leaksRedacted++;
+        redactedTypes.push(label);
+        sanitized = sanitized.replace(regex, label);
+      }
+    }
+
+    const latencyMs = Math.round((performance.now() - start) * 1000) / 1000;
+
+    return {
+      isSafe: leaksRedacted === 0,
+      sanitizedText: sanitized,
+      leaksRedacted,
+      redactedTypes,
+      latencyMs
+    };
+  }
+}

package/src/guard.ts

@@ -0,0 +1,119 @@
+import { PromptInspectionResult } from "./types";
+
+const ZERO_WIDTH_CHARS = [
+  "\u200B", "\u200C", "\u200D", "\uFEFF", "\u202E", "\u202D"
+];
+
+export const FAST_INJECTION_PATTERNS: Array<{ regex: RegExp; category: string; score: number }> = [
+  {
+    regex: /\b(?:ignore|disregard|forget|skip|drop|override|bypass|disable|negate|cancel|erase)\s+(?:all\s+)?(?:(?:previous|prior|above|former|initial|system)\s+)?(?:instructions?|prompts?|rules?|commands?|guidelines?|context|constraints?|directives?|filters?|guardrails?)/i,
+    category: "DIRECT_OVERRIDE",
+    score: 0.96
+  },
+  {
+    regex: /\bignore\s+(?:all\s+)?(?:the\s+)?(?:previous|prior|above|safety|system)/i,
+    category: "DIRECT_OVERRIDE",
+    score: 0.95
+  },
+  {
+    regex: /\bnew\s+rule:\s*(?:ignore|disregard|forget|override)/i,
+    category: "DIRECT_OVERRIDE",
+    score: 0.92
+  },
+  {
+    regex: /\byou\s+are\s+now\s+(?:DAN|unfiltered|jailbroken|unrestricted|free\s+of\s+rules|an\s+adversary|in\s+developer\s+mode|in\s+god\s+mode)/i,
+    category: "JAILBREAK_ROLEPLAY",
+    score: 0.94
+  },
+  {
+    regex: /\bdo\s+anything\s+now\b/i,
+    category: "JAILBREAK_DAN",
+    score: 0.96
+  },
+  {
+    regex: /\bpretend\s+you\s+have\s+no\s+(?:safety|ethical|content)\s+filters?/i,
+    category: "JAILBREAK_SAFETY_BYPASS",
+    score: 0.90
+  },
+  {
+    regex: /\b(?:print|show|dump|reveal|output|display|repeat|leak)\s+(?:your\s+)?(?:system\s+prompts?|initial\s+instructions?|system\s+instructions?|core\s+rules?|internal\s+prompts?|credentials?|passwords?|api\s*keys?|secrets?)/i,
+    category: "SYSTEM_PROMPT_EXTRACTION",
+    score: 0.92
+  },
+  {
+    regex: /\b(?:delete|drop|wipe|purge|truncate|destroy)\s+(?:everything|all\s+data|all\s+tables|database|users?|system)\b/i,
+    category: "DESTRUCTIVE_DATABASE_EXECUTION",
+    score: 0.96
+  },
+  {
+    regex: /(?:union\s+select|select\s+.*\s+from\s+|insert\s+into\s+|drop\s+table|delete\s+from\s+|truncate\s+table|exec\s+sp_|xp_cmdshell|or\s+1\s*=\s*1|'\s*or\s*'1'\s*=\s*'1|--|\bwaitfor\s+delay\b)/i,
+    category: "SQLI_PARAMETER_INJECTION",
+    score: 0.96
+  },
+  {
+    regex: /\[system\s+override\]|<\s*system(?:\s+override)?\s*>|```\s*(?:system|override|admin)/i,
+    category: "SYNTHETIC_DELIMITER_INJECTION",
+    score: 0.94
+  }
+];
+
+export const FAST_TOXICITY_RE = /\b(?:f+u+c+k+|s+h+i+t+|b+i+t+c+h+|asshole|kill\s+yourself|bomb\s+the|murder\s+you)\b/i;
+
+export function normalizeInputText(text: string): string {
+  if (!text) return "";
+  let cleaned = text;
+  for (const char of ZERO_WIDTH_CHARS) {
+    cleaned = cleaned.split(char).join("");
+  }
+  return cleaned.normalize("NFKD");
+}
+
+export function inspectInput(prompt: string, threshold = 0.65): PromptInspectionResult {
+  const start = performance.now();
+  if (!prompt || typeof prompt !== "string") {
+    return {
+      isSafe: true,
+      action: "ALLOW",
+      riskScore: 0.0,
+      matchedPatterns: [],
+      sanitizedText: prompt || "",
+      latencyMs: 0.0
+    };
+  }
+
+  const normalized = normalizeInputText(prompt);
+  const matchedPatterns: string[] = [];
+  let maxRisk = 0.0;
+  let threatCategory: string | null = null;
+
+  for (const item of FAST_INJECTION_PATTERNS) {
+    if (item.regex.test(normalized) || item.regex.test(prompt)) {
+      matchedPatterns.push(item.category);
+      if (item.score > maxRisk) {
+        maxRisk = item.score;
+        threatCategory = item.category;
+      }
+    }
+  }
+
+  if (FAST_TOXICITY_RE.test(prompt)) {
+    matchedPatterns.push("VULGARITY_VIOLATION");
+    if (0.88 > maxRisk) {
+      maxRisk = 0.88;
+      threatCategory = "VULGARITY_VIOLATION";
+    }
+  }
+
+  const isSafe = maxRisk < threshold && matchedPatterns.length === 0;
+  const elapsedMs = Math.round((performance.now() - start) * 1000) / 1000;
+
+  return {
+    isSafe,
+    action: isSafe ? "ALLOW" : "BLOCK",
+    riskScore: maxRisk,
+    threatDetected: threatCategory,
+    matchedPatterns,
+    sanitizedText: isSafe ? prompt : `[BLOCKED_BY_SECUREAI: ${threatCategory}]`,
+    latencyMs: elapsedMs
+  };
+}

package/src/index.ts

@@ -0,0 +1,12 @@
+/**
+ * @secureai/sdk
+ * Enterprise AI Security, GrokBot Firewall, Agent Action Armor & Reversible PII Vault
+ * Powered by AcadmyAI (https://secure.acadmyai.com)
+ */
+
+export * from "./types";
+export * from "./guard";
+export * from "./vault";
+export * from "./grok-bot";
+export * from "./client";
+export * from "./mcp-proxy";

package/src/mcp-proxy.ts

@@ -0,0 +1,94 @@
+import { spawn } from "child_process";
+import * as readline from "readline";
+
+const SQLI_REGEX = /(?:union\s+select|drop\s+table|delete\s+from|insert\s+into|truncate\s+table|--|\bwaitfor\s+delay\b)/i;
+const TRAVERSAL_REGEX = /(?:\.\.\/|\.\.\\|\/\.env|id_rsa|credentials)/i;
+
+export interface MCPProxyOptions {
+  targetCommand: string;
+  targetArgs: string[];
+  apiKey?: string;
+  policy?: "read-only-strict" | "standard" | "developer";
+}
+
+export function startMCPProxy(options: MCPProxyOptions): void {
+  const apiKey = options.apiKey || process.env.SECUREAI_API_KEY;
+  if (!apiKey) {
+    process.stderr.write(
+      "[SecureAI MCP Proxy ERROR]: SECUREAI_API_KEY environment variable is required.\n" +
+      "Generate an API key at https://secure.acadmyai.com/console/apikeys\n"
+    );
+    process.exit(1);
+  }
+
+  process.stderr.write(
+    `[SecureAI MCP Proxy]: Zero-Trust interceptor active for '${options.targetCommand} ${options.targetArgs.join(" ")}'\n`
+  );
+
+  const targetProcess = spawn(options.targetCommand, options.targetArgs, {
+    stdio: ["pipe", "pipe", "inherit"],
+    env: process.env
+  });
+
+  // Intercept Agent -> MCP Target (stdin)
+  const rlStdin = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: false
+  });
+
+  rlStdin.on("line", (line: string) => {
+    if (!line.trim()) return;
+    try {
+      const msg = JSON.parse(line);
+      if (msg.method === "tools/call") {
+        const toolName = msg.params?.name || "";
+        const argsStr = JSON.stringify(msg.params?.arguments || {});
+
+        // 1. SQL Injection Parameter Check
+        if (SQLI_REGEX.test(argsStr)) {
+          process.stderr.write(`[SecureAI MCP BLOCKED]: SQL Injection detected in tool '${toolName}' arguments.\n`);
+          const blockedResp = {
+            jsonrpc: "2.0",
+            id: msg.id,
+            error: {
+              code: -32000,
+              message: `SecureAI Policy Block: SQL Injection signature detected in parameters for tool '${toolName}'.`
+            }
+          };
+          process.stdout.write(JSON.stringify(blockedResp) + "\n");
+          return;
+        }
+
+        // 2. Path Traversal & Sensitive File Access Check
+        if (TRAVERSAL_REGEX.test(argsStr)) {
+          process.stderr.write(`[SecureAI MCP BLOCKED]: Path traversal or secret file access detected in tool '${toolName}'.\n`);
+          const blockedResp = {
+            jsonrpc: "2.0",
+            id: msg.id,
+            error: {
+              code: -32000,
+              message: `SecureAI Policy Block: Path traversal or unauthorized secret access forbidden in tool '${toolName}'.`
+            }
+          };
+          process.stdout.write(JSON.stringify(blockedResp) + "\n");
+          return;
+        }
+      }
+
+      // Forward sanitized command to target
+      targetProcess.stdin.write(line + "\n");
+    } catch {
+      targetProcess.stdin.write(line + "\n");
+    }
+  });
+
+  // Forward Target MCP -> Agent (stdout)
+  targetProcess.stdout.on("data", (chunk: Buffer | string) => {
+    process.stdout.write(chunk);
+  });
+
+  targetProcess.on("exit", (code: number | null) => {
+    process.exit(code ?? 0);
+  });
+}

package/src/types.ts

@@ -0,0 +1,124 @@
+/**
+ * SecureAI TypeScript SDK Types
+ * Enterprise AI Security, GrokBot Firewall, Agent Action Armor & Reversible PII Vault
+ */
+
+export type ThreatSeverity = "CRITICAL" | "HIGH" | "MEDIUM" | "LOW" | "INFO";
+
+export type SecurityAction = "ALLOW" | "BLOCK" | "REWRITE_SAFE" | "STEP_UP_HITL" | "ALLOW_WITH_TOKENIZATION";
+
+export interface UserSecurityContext {
+  userId?: string;
+  role?: "admin" | "analyst" | "developer" | "guest";
+  department?: string;
+  clearanceLevel?: 1 | 2 | 3 | 4 | 5;
+  sessionId?: string;
+}
+
+export interface PromptInspectionResult {
+  isSafe: boolean;
+  action: SecurityAction;
+  riskScore: number;
+  threatDetected?: string | null;
+  matchedPatterns: string[];
+  sanitizedText: string;
+  latencyMs: number;
+  quota?: {
+    tier: string;
+    used: number;
+    limit: number;
+    remaining: number;
+  };
+}
+
+export interface BotIngressResult {
+  isSafe: boolean;
+  sanitizedText: string;
+  threatDetected?: string | null;
+  riskScore: number;
+  latencyMs: number;
+  matchedPatterns: string[];
+}
+
+export interface BotToolResult {
+  allowed: boolean;
+  toolName: string;
+  requiredClearance: number;
+  botClearance: number;
+  syntheticError?: string | null;
+  reason?: string | null;
+}
+
+export interface BotEgressResult {
+  isSafe: boolean;
+  sanitizedText: string;
+  leaksRedacted: number;
+  redactedTypes: string[];
+  latencyMs: number;
+}
+
+export interface AgentActionPayload {
+  actionType: "EXECUTE_SHELL" | "WRITE_FILE" | "READ_FILE" | "NETWORK_EGRESS";
+  target: string;
+  command?: string;
+  userContext?: UserSecurityContext;
+}
+
+export interface AgentActionVerdict {
+  verdict: SecurityAction;
+  isAllowed: boolean;
+  riskScore: number;
+  threatsDetected: string[];
+  rewrittenCommand?: string | null;
+  explanation?: string;
+  tamperProofSignature?: string;
+}
+
+export interface PIIVaultResult {
+  sanitizedText: string;
+  redactedCount: number;
+  tokenMap: Record<string, string>;
+}
+
+export interface ModelScanResult {
+  isSafe: boolean;
+  verdict: "SAFE" | "BLOCKED" | "MALICIOUS";
+  riskScore: number;
+  maliciousOpcodes: string[];
+  formatDetected: string;
+  explanation: string;
+}
+
+export interface ServiceConfigItem {
+  enabled: boolean;
+  mode?: string;
+  threshold?: number;
+  clearanceLevel?: number;
+  description?: string;
+  [key: string]: any;
+}
+
+export interface ServicesConfig {
+  prompt_injection_guard?: ServiceConfigItem;
+  pii_vault?: ServiceConfigItem;
+  agent_action_firewall?: ServiceConfigItem;
+  mcp_gateway?: ServiceConfigItem;
+  bot_firewall?: ServiceConfigItem;
+  rag_context_guard?: ServiceConfigItem;
+  grounding_scorer?: ServiceConfigItem;
+  model_scanner?: ServiceConfigItem;
+  canary_vault?: ServiceConfigItem;
+  toxicity_filter?: ServiceConfigItem;
+  semantic_cache?: ServiceConfigItem;
+  redteam_simulator?: ServiceConfigItem;
+  aspm_engine?: ServiceConfigItem;
+  aibom_generator?: ServiceConfigItem;
+  [key: string]: ServiceConfigItem | undefined;
+}
+
+export interface SecureAIClientOptions {
+  apiKey?: string;
+  baseUrl?: string;
+  timeoutMs?: number;
+  services?: ServicesConfig;
+}

package/src/vault.ts

@@ -0,0 +1,47 @@
+import { PIIVaultResult } from "./types";
+
+const PII_PATTERNS: Array<{ type: string; regex: RegExp }> = [
+  { type: "SSN", regex: /\b\d{3}-\d{2}-\d{4}\b/g },
+  { type: "CREDIT_CARD", regex: /\b(?:4[0-9]{12}(?:[0-9]{3})?|5[1-5][0-9]{14}|3[47][0-9]{13})\b/g },
+  { type: "EMAIL", regex: /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b/g },
+  { type: "PHONE", regex: /\b(?:\+?\d{1,3}[-.\s]?)?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}\b/g },
+  { type: "API_KEY", regex: /\b(?:sk-[a-zA-Z0-9]{20,}|sec_live_[a-zA-Z0-9]{16,}|ghp_[a-zA-Z0-9]{36,})\b/g }
+];
+
+export class PIIVault {
+  public tokenize(text: string): PIIVaultResult {
+    if (!text) {
+      return { sanitizedText: "", redactedCount: 0, tokenMap: {} };
+    }
+
+    let sanitized = text;
+    const tokenMap: Record<string, string> = {};
+    let count = 0;
+
+    for (const { type, regex } of PII_PATTERNS) {
+      sanitized = sanitized.replace(regex, (match) => {
+        count++;
+        const token = `[SEC_${type}_${Math.random().toString(36).substring(2, 8).toUpperCase()}]`;
+        tokenMap[token] = match;
+        return token;
+      });
+    }
+
+    return {
+      sanitizedText: sanitized,
+      redactedCount: count,
+      tokenMap
+    };
+  }
+
+  public detokenize(text: string, tokenMap: Record<string, string>): string {
+    if (!text || !tokenMap) return text;
+    let restored = text;
+    for (const [token, original] of Object.entries(tokenMap)) {
+      restored = restored.split(token).join(original);
+    }
+    return restored;
+  }
+}
+
+export const defaultVault = new PIIVault();

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "CommonJS",
+    "moduleResolution": "Node",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "typeRoots": ["../../frontend/node_modules/@types"]
+  },
+  "include": ["src/**/*"]
+}