agentgate-runtime-control 2.13.8

package/docs/production-quickstart.md

@@ -0,0 +1,58 @@
+# Production Quickstart: PostgreSQL
+
+This is a reference deployment for a pilot. Put a TLS reverse proxy in front of AgentGate in any non-local deployment.
+
+## 1. Set the database secret
+
+```bash
+export POSTGRES_PASSWORD='use-a-long-random-secret'
+```
+
+## 2. Start PostgreSQL and AgentGate
+
+```bash
+docker compose -f docker-compose.production.yml up -d --build
+```
+
+## 3. Verify readiness
+
+```bash
+curl -fsS http://127.0.0.1:8787/api/health
+curl -fsS http://127.0.0.1:8787/api/ready
+```
+
+## 4. Verify the database schema
+
+The compose file mounts `schema/postgres.sql` as an initialization script. For an existing database, apply the schema through your normal migration/change-management process instead of relying on container initialization.
+
+The schema must have:
+
+- `agentgate_records`
+- `(tenant_id, kind)` index
+- RLS enabled
+- tenant-scoped `USING` and `WITH CHECK` policy
+
+## 5. Production hardening
+
+- Replace the sample password with a secret-manager value.
+- Put the Control Plane behind HTTPS/OIDC or another production authentication boundary.
+- Do not publish PostgreSQL directly to the Internet.
+- Configure automated backups and test restore into an isolated database.
+- Configure monitoring for `/api/health`, `/api/ready`, error rate, latency and database connectivity.
+- Keep the exact image/package version and database schema version together for rollback decisions.
+
+## 6. Backup/restore acceptance test
+
+Record:
+
+```text
+backup timestamp:
+backup identifier:
+restore target:
+restore duration:
+RPO:
+RTO:
+replay verification:
+approval verification:
+tenant-isolation verification:
+```

package/docs/production-readiness.md

@@ -0,0 +1,29 @@
+# Production Readiness Status — 2.13.8
+
+## Completed in the release
+
+- Runtime/SDK enforcement and approval lifecycle.
+- Live `agentgate dev` Attack Lab with 5/5 demo tools.
+- Explicit SKIPPED handling for missing tools in real gateways.
+- Control Plane policy lifecycle and audit export.
+- Browser syntax/release smoke coverage.
+- Tenant isolation, egress controls, malformed-input handling and approval race tests.
+- 139/139 automated tests passing.
+- Reproducible performance benchmark and recorded baseline.
+- PostgreSQL/Supabase deployment reference and RLS schema checks.
+- Docker Compose production pilot reference.
+- Retention, encryption, backup/restore and deletion guidance.
+- Incident-response runbook.
+- Threat model and integration matrix.
+- Release consistency and npm artifact checks.
+
+## Environment-dependent gates
+
+These cannot be truthfully marked complete inside the source archive alone:
+
+1. **Backup/restore execution:** run against the customer's real PostgreSQL/Supabase environment and record RPO/RTO.
+2. **Production monitoring/alerting:** connect the documented metrics and health probes to the customer's monitoring system.
+3. **Customer-specific integration validation:** run the actual agent/framework/tool stack.
+4. **External security review:** an independent reviewer must perform and sign off on the agreed scope.
+
+The release intentionally does not claim any of these have been completed.

package/docs/quickstart.md

@@ -0,0 +1,115 @@
+# AgentGate Quickstart
+
+
+## 0. Start with a policy pack
+
+For the fastest first protection, use the Support Refund Safety Pack:
+
+```bash
+npx agentgate pack list
+npx agentgate pack init support-refund-safety
+npx agentgate simulate
+npx agentgate attack
+```
+
+The generated config starts in `enforce` mode. For a focused Shadow/Observe demonstration, explicitly change `mode` to `observe` and do not use that configuration for sensitive production tools:
+
+```bash
+npx agentgate demo refund
+```
+
+See [`docs/design-partner.md`](design-partner.md) for the observe → enforce rollout and acceptance criteria.
+
+AgentGate is a runtime control plane for AI agent tool execution. Put it between your agent and side-effecting tools so every action gets a deterministic `ALLOW`, `ASK`, or `BLOCK` decision.
+
+## 1. Install
+
+```bash
+npm install agentgate-runtime-control
+```
+
+## 2. Protect a tool
+
+```js
+import { protect } from 'agentgate-runtime-control';
+
+const refund = protect(
+  async ({ amount, customerId }) => ({ refunded: amount, customerId }),
+  {
+    approvalActions: ['refund'],
+    autoApproveAmount: 500,
+    approvalAmount: 5000
+  }
+);
+
+await refund({ amount: 250, customerId: 'cus_123' });
+// status: executed
+
+await refund({ amount: 1200, customerId: 'cus_123' });
+// status: approval_required
+
+// amount 9000 is BLOCKED because it exceeds approvalAmount
+```
+
+## 3. Run the attack lab
+
+```bash
+npx agentgate attack
+```
+
+The lab exercises representative destructive, export, escalation, and high-value actions through the same gateway path used at runtime.
+
+## 4. Start the local control plane
+
+```bash
+npx agentgate dev
+```
+
+Then open `http://localhost:8787`. Local development creates a short-lived browser session automatically; production authentication remains required.
+
+The dashboard starts with seeded ALLOW / ASK / BLOCK demo runs so you can verify the control plane before connecting your own agent.
+
+Useful endpoints include:
+
+- `/api/health` — process health
+- `/api/ready` — readiness state
+- `/api/metrics` — runtime telemetry
+- `/api/runs` — replayable runs
+- `/api/approvals` — pending approvals
+- `/api/behavior` — behavior signals
+- `/api/blast-radius` — blast-radius analysis
+
+## 5. Start from the CLI
+
+```bash
+npx agentgate init
+```
+
+This creates `agentgate.config.mjs` with a conservative production policy baseline.
+
+## 6. Recommended rollout
+
+1. Start in `observe` mode.
+2. Run your normal agent traffic.
+3. Run `agentgate attack` and your own abuse cases.
+4. Review replay IDs, behavior signals, and generated reports.
+5. Activate reviewed policies.
+6. Switch to `enforce` mode for production side effects.
+7. Keep approvals and audit events connected to your operational workflow.
+
+AgentGate is a control layer, not a guarantee that an agent is safe. Test the actions and tools that matter to your application.
+
+
+## Approval lifecycle for `createAgentGate`
+
+When a protected SDK tool returns `approval_required`, the returned `approvalId` is resolved through the same gate:
+
+```js
+const result = await refund({ amount: 900 });
+if (result.status === 'approval_required') {
+  const approved = await gate.approve(result.approvalId);
+  // or: await gate.deny(result.approvalId, 'Not authorized');
+}
+```
+
+You can inspect pending requests with `gate.approvals()` and retrieve one with `gate.getApproval(approvalId)`. The approval API executes the original protected tool only after explicit approval.

package/docs/release-checklist.md

@@ -0,0 +1,33 @@
+# Production Release Checklist
+
+## Automated gate
+
+- [ ] `npm test` is green.
+- [ ] `node scripts/release-check.mjs` is green.
+- [ ] `npm pack --dry-run` contains no tests, internal tarballs, or stale versions.
+- [ ] `node --check` passes for extracted standalone JavaScript.
+- [ ] release browser smoke passes.
+- [ ] `agentgate dev` Live Attack Lab returns 5/5 protected in its demo environment.
+- [ ] clean consumer install from the generated npm tarball passes.
+- [ ] approval race test confirms exactly one execution.
+- [ ] tenant isolation test passes.
+- [ ] egress test passes.
+
+## Operational gate
+
+- [ ] Production PostgreSQL/Supabase is configured with RLS.
+- [ ] TLS is enabled.
+- [ ] Backup and restore have been exercised.
+- [ ] Retention period is documented by the deployment owner.
+- [ ] RPO/RTO are documented by the deployment owner.
+- [ ] Incident-response contacts/runbook are configured.
+- [ ] Monitoring and alerting are configured.
+- [ ] Application-specific abuse cases are recorded.
+
+## Assurance gate
+
+- [ ] Threat model reviewed.
+- [ ] Dependency/supply-chain review completed.
+- [ ] External security review completed, if required by the customer/plan.
+
+An unchecked external-review item must never be described as completed or certified.

package/docs/security-hardening-release-report.md

@@ -0,0 +1,69 @@
+# AgentGate v2.13.8 — Security Hardening Release Report
+
+## Changes closed from the v2.13.7 verification report
+
+### 1. Generic secret detection
+
+Added default field-aware egress protection for:
+
+- `secret`
+- `password`
+- `passphrase`
+- `private_key`
+- `access_token`
+- `refresh_token`
+- `authorization`
+- `auth_token`
+- `client_secret`
+- `api_secret`
+
+Sensitive values are redacted as `[REDACTED:SECRET]` and the egress decision is `BLOCK` by default.
+
+Regression coverage includes nested objects, arrays, inspection, and existing MCP egress behavior.
+
+### 2. Enforcement configuration
+
+The shipped `agentgate.config.mjs` now uses `mode: 'enforce'` so the packaged runtime example does not accidentally present Observe as an enforcement configuration.
+
+Observe remains supported for explicit shadow/testing workflows.
+
+### 3. PostgreSQL reference hardening
+
+The reference schema now uses both:
+
+```sql
+ALTER TABLE agentgate_records ENABLE ROW LEVEL SECURITY;
+ALTER TABLE agentgate_records FORCE ROW LEVEL SECURITY;
+```
+
+The managed production acceptance procedure remains separate because it requires a real managed PostgreSQL environment.
+
+### 4. External security review
+
+No external audit is claimed. The release contains a reviewer-ready test pack covering authentication, authorization, tenant isolation, runtime enforcement, approval races, egress, malformed input, MCP boundaries, replay/audit integrity, persistence, and abuse controls.
+
+### 5. Managed PostgreSQL production acceptance
+
+The release contains a provider-neutral acceptance test covering RLS, tenant isolation, backup/restore, application-role privileges, TLS, RPO/RTO, and restore verification.
+
+## Release verification executed in this environment
+
+- `npm test` — 144/144 PASS.
+- `node bin/agentgate.js --version` — 2.13.8.
+- `node bin/agentgate.js doctor` — OK, enforce mode, no warnings.
+- `node bin/agentgate.js validate-security` — OK.
+- `node bin/agentgate.js attack-ci` — 5/5 PROTECTED.
+- `node --test test/release-browser-smoke.mjs` — PASS.
+- `npm run benchmark` — PASS, environment-specific baseline.
+- `npm run release:check` — PASS.
+- `npm audit --omit=dev` — 0 vulnerabilities reported.
+
+## Remaining evidence gates
+
+These cannot honestly be marked complete by an internal local build:
+
+1. Independent external security review — requires an independent reviewer and dated report.
+2. Managed PostgreSQL production acceptance — requires the target managed PostgreSQL environment and its backup/restore evidence.
+3. Production SLA/capacity — requires HTTP + managed DB + network testing in the target deployment environment.
+
+The release therefore closes the code-level finding and packages the remaining independent/production evidence tests without falsely claiming those external validations.

package/docs/threat-model.md

@@ -0,0 +1,47 @@
+# AgentGate Threat Model
+
+## Assets
+
+- Tool execution authority.
+- Approval decisions.
+- Run/replay evidence.
+- Tenant-scoped audit data.
+- Policy definitions and versions.
+- Credentials used by the protected application.
+
+## Trust boundaries
+
+```text
+Untrusted model/agent
+        |
+        v
+AgentGate runtime boundary
+        |
+        +--> policy engine
+        +--> approval boundary
+        +--> egress guard
+        +--> audit/persistence
+        |
+        v
+Side-effecting tool / MCP / API
+```
+
+## Threats and controls
+
+| Threat | Primary control | Evidence |
+|---|---|---|
+| Prompt injection causes dangerous tool call | Deterministic tool/action policy | Attack Lab |
+| High-value action bypasses approval | ASK before handler execution | Approval tests |
+| Double approval causes duplicate side effect | Single-resolution approval state | Approval race test |
+| Destructive tool executes | BLOCK before handler | Security validation / Attack Lab |
+| Cross-tenant replay/read | Tenant-scoped API and persistence | Tenant tests + RLS schema |
+| Secret/PII leaves tool boundary | Egress inspection | Egress tests |
+| Policy drift | Versioned policy registry/test/activate | Policy lifecycle tests |
+| Audit loss during rollback | Export + durable store + backup procedure | Operations runbook |
+| Credential theft outside AgentGate | Application/IAM/secret-manager controls | Out of scope |
+| Compromised host/kernel | Infrastructure security | Out of scope |
+| Unsafe model output without tool call | Model/provider safety controls | Out of scope |
+
+## Security boundary
+
+AgentGate is an execution-control layer. It is not an IAM replacement, secret manager, network firewall, model safety guarantee, or host security boundary.

package/docs/website-copy.md

@@ -0,0 +1,44 @@
+# AgentGate Website Copy — Launch Draft
+
+## Hero
+**Control what your AI agents can actually do.**
+
+AgentGate is the runtime control plane for AI agent actions. Stop dangerous tool calls before they execute, require approval for sensitive actions, and keep replayable evidence of every decision.
+
+**CTA:** Start with the SDK
+**Secondary CTA:** Run the Attack Lab
+
+## Proof strip
+`ALLOW` · `ASK` · `BLOCK` · Approval boundaries · Egress protection · Tenant isolation · Replay
+
+## How it works
+**Install → Observe → Attack → Enforce → Replay**
+
+AgentGate sits between your agent and its tools. The model can request an action; AgentGate makes the deterministic runtime decision.
+
+## Why AgentGate
+### Prevent side effects
+A BLOCK decision happens before the protected handler executes.
+
+### Make approvals real
+Sensitive actions can pause for human approval. No pre-approval handler execution.
+
+### Prove what happened
+Every important decision can carry a winning rule, rule trace, execution outcome, and Replay evidence.
+
+### Start without production risk
+Use sandbox, replay traffic, and Shadow Mode before enforcing a sensitive tool.
+
+## Use cases
+- Support and financial operations: refunds, cancellations, customer changes.
+- DevOps and IT: deployments, production changes, destructive operations.
+- Data and CRM: exports, bulk updates, cross-tenant access.
+
+## Security boundary
+AgentGate is a runtime control layer. It does not replace application authorization, IAM, secret management, network isolation, provider controls, or threat modeling.
+
+## CTA
+**Give one agent one sensitive tool. See what AgentGate would allow, ask, and block.**
+
+Install:
+`npm install agentgate-runtime-control`

package/examples/basic.mjs

@@ -0,0 +1,14 @@
+import { protect } from 'agentgate-runtime-control';
+
+const refund = protect(
+  async ({ amount, customerId }) => ({ refunded: amount, customerId }),
+  { autoApproveAmount: 500, approvalAmount: 5000, requireApprovalForDestructive: false }
+);
+
+console.log(await refund({ amount: 250, customerId: 'cus_123' })); // executed
+console.log(await refund({ amount: 1200, customerId: 'cus_123' })); // approval_required
+try {
+  await refund({ amount: 9000, customerId: 'cus_123' });
+} catch (error) {
+  console.log({ status: 'blocked', decision: error.agentgate.decision, reason: error.agentgate.reason });
+}

package/examples/control-plane.mjs

@@ -0,0 +1,17 @@
+import fs from 'node:fs/promises';
+import { createControlPlane } from '../src/control-plane.js';
+import { createMCPGateway } from '../src/mcp-gateway.js';
+
+const html = await fs.readFile(new URL('../standalone.html', import.meta.url), 'utf8');
+const gateway = createMCPGateway({
+  mode: 'enforce',
+  policies: { productionBlock: true },
+  tools: [
+    { name: 'read', handler: async (args) => ({ ok: true, data: args }) },
+    { name: 'refund', handler: async (args) => ({ refunded: args.amount }) },
+    { name: 'delete', handler: async (args) => ({ deleted: args.id }) }
+  ]
+});
+const { server } = createControlPlane({ gateway, html });
+const port = Number(process.env.PORT || 8787);
+server.listen(port, () => console.log(`AgentGate Control Plane: http://localhost:${port}`));

package/examples/design-partner-refund.mjs

@@ -0,0 +1,33 @@
+import { createAgentGate, getPolicyPack } from 'agentgate-runtime-control';
+
+const pack = getPolicyPack('support-refund-safety');
+const gate = createAgentGate({
+  agent: 'SupportAgent',
+  mode: 'observe',
+  policies: pack.policies
+});
+
+let executions = 0;
+const refund = gate.protect(
+  async ({ amount, customerId }) => {
+    executions += 1;
+    return { refunded: amount, customerId };
+  },
+  { tool: 'refund', action: 'refund' }
+);
+
+for (const amount of [250, 1200, 5000.01]) {
+  const result = await refund(
+    { amount, customerId: 'sandbox_customer' },
+    { amount, environment: 'production' }
+  );
+  console.log({
+    amount,
+    proposedDecision: result.agentgate.decision,
+    winningRule: result.agentgate.winningRule,
+    simulated: result.agentgate.simulated,
+    handlerExecuted: result.status === 'executed'
+  });
+}
+
+console.log({ mode: gate.mode, executions, note: 'Observe mode records proposed decisions and intentionally does not enforce them.' });

package/examples/design-partner-shadow.mjs

@@ -0,0 +1,27 @@
+import { createAgentGate, getPolicyPack, recordShadowEvent, analyzeShadowEvents } from 'agentgate-runtime-control';
+
+const pack = getPolicyPack('support-refund-safety');
+const gate = createAgentGate({ agent: 'SupportAgent', mode: 'observe', policies: pack.policies });
+const events = [];
+
+async function refundTool({ amount, customerId }) {
+  return { refunded: amount, customerId };
+}
+
+const refund = gate.protect(refundTool, { tool: 'refund', action: 'refund' });
+
+for (const amount of [250, 1200, 5000.01]) {
+  const result = await refund({ amount, customerId: 'sandbox_customer' }, { amount });
+  events.push(recordShadowEvent({
+    runId: result.agentgate.id,
+    decision: result.agentgate.decision,
+    executed: result.status === 'executed',
+    request: result.agentgate.request
+  }));
+}
+
+console.log(JSON.stringify({
+  mode: gate.mode,
+  shadow: analyzeShadowEvents(events),
+  events
+}, null, 2));

package/examples/mcp-gateway.mjs

@@ -0,0 +1,26 @@
+import { createMCPGatewayServer } from '../src/mcp-gateway.js';
+
+const { server } = createMCPGatewayServer({
+  mode: 'enforce',
+  policies: {
+    approvalActions: ['refund'],
+    blockActions: ['export_all']
+  },
+  tools: [
+    {
+      name: 'read_customer',
+      description: 'Read a customer record',
+      inputSchema: { type: 'object', properties: { customerId: { type: 'string' } } },
+      handler: async ({ customerId }) => ({ customerId, name: 'Demo Customer' })
+    },
+    {
+      name: 'refund',
+      description: 'Issue a refund',
+      inputSchema: { type: 'object', properties: { amount: { type: 'number' } } },
+      handler: async ({ amount }) => ({ refunded: amount })
+    }
+  ]
+});
+
+const port = Number(process.env.PORT || 8787);
+server.listen(port, () => console.log(`AgentGate MCP Gateway listening on http://localhost:${port}/mcp`));

package/examples/policy-bundle.mjs

@@ -0,0 +1,18 @@
+import { createPolicyBundleRegistry } from 'agentgate-runtime-control';
+
+const registry = createPolicyBundleRegistry({ filePath: '.agentgate/policy-bundles.json' });
+
+const bundle = registry.create('support-production', {
+  productionBlock: true,
+  approvalActions: ['refund', 'delete'],
+  autoApproveAmount: 500,
+  approvalAmount: 5000
+});
+
+registry.test('support-production', bundle.version, [
+  { input: { action: 'read', environment: 'production' }, expected: 'ALLOW' },
+  { input: { action: 'refund', amount: 1200, environment: 'staging' }, expected: 'ASK' },
+  { input: { action: 'delete', environment: 'production' }, expected: 'BLOCK' }
+]);
+
+console.log(registry.activate('support-production', bundle.version));

package/examples/refund-agent.mjs

@@ -0,0 +1,20 @@
+import { createAgentGate } from 'agentgate-runtime-control';
+
+const gate = createAgentGate({
+  agent: 'SupportAgent',
+  mode: 'enforce',
+  policies: { productionBlock: true, autoApproveAmount: 500, approvalAmount: 5000 }
+});
+
+const refund = gate.protect(
+  async ({ amount, customerId }) => ({ refunded: amount, customerId }),
+  { tool: 'refund', action: 'refund' }
+);
+
+for (const amount of [250, 1200]) {
+  try {
+    console.log(await refund({ amount, customerId: 'cus_123' }));
+  } catch (error) {
+    console.log({ status: 'blocked', code: error.code, decision: error.agentgate?.decision, reason: error.agentgate?.reason });
+  }
+}

package/examples/runtime.mjs

@@ -0,0 +1,12 @@
+import { createRuntime, runAttackLab } from 'agentgate-runtime-control';
+
+const gate = createRuntime({ mode: 'enforce', policies: { productionBlock: true, approvalAmount: 5000, autoApproveAmount: 500 } });
+const charge = async ({ amount }) => ({ charged: amount });
+
+try {
+  console.log(await gate.execute(charge, { action: 'refund', amount: 120 }));
+} catch (error) {
+  console.log({ status: 'blocked', code: error.code, decision: error.agentgate?.decision, reason: error.agentgate?.reason });
+}
+console.log(gate.runs());
+console.table(runAttackLab({ productionBlock: true }));

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "agentgate-runtime-control",
+  "version": "2.13.8",
+  "type": "module",
+  "description": "Runtime control plane and SaaS governance layer for AI agent tool execution",
+  "exports": {
+    ".": "./src/index.js",
+    "./policy-engine": "./src/policy-engine.js",
+    "./mcp-gateway": "./src/mcp-gateway.js",
+    "./policy-builder": "./src/policy-builder.js",
+    "./control-plane": "./src/control-plane.js",
+    "./agentgate": "./src/agentgate.js",
+    "./security-report": "./src/security-report.js",
+    "./behavior": "./src/behavior.js",
+    "./identity": "./src/identity.js",
+    "./policy-registry": "./src/policy-registry.js",
+    "./multi-tenant": "./src/multi-tenant.js",
+    "./telemetry": "./src/telemetry.js",
+    "./oidc": "./src/oidc.js",
+    "./saas": "./src/saas.js",
+    "./mcp-scanner": "./src/mcp-scanner.js",
+    "./egress-guard": "./src/egress-guard.js",
+    "./observability": "./src/observability.js"
+  },
+  "bin": {
+    "agentgate": "./bin/agentgate.js"
+  },
+  "scripts": {
+    "test": "node --test",
+    "prepublishOnly": "npm test",
+    "benchmark": "node scripts/performance-benchmark.mjs",
+    "release:check": "node scripts/release-check.mjs"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "src",
+    "bin",
+    "examples",
+    "schema",
+    "docs",
+    "standalone.html",
+    "README.md",
+    "LICENSE",
+    "SECURITY.md",
+    "CHANGELOG.md"
+  ]
+}

package/schema/postgres.sql

@@ -0,0 +1,17 @@
+-- AgentGate production Postgres schema
+-- Runtime database sessions should set: select set_config('agentgate.tenant_id', '<tenant>', true);
+create table if not exists agentgate_records (
+  id text primary key,
+  tenant_id text not null,
+  kind text not null,
+  data jsonb not null,
+  version integer not null default 1,
+  created_at timestamptz not null default now()
+);
+create index if not exists agentgate_records_tenant_kind_idx on agentgate_records (tenant_id, kind);
+alter table agentgate_records enable row level security;
+alter table agentgate_records force row level security;
+drop policy if exists agentgate_tenant_isolation on agentgate_records;
+create policy agentgate_tenant_isolation on agentgate_records
+  using (tenant_id = current_setting('agentgate.tenant_id', true))
+  with check (tenant_id = current_setting('agentgate.tenant_id', true));

package/src/admin-rbac.js

@@ -0,0 +1,3 @@
+export const ADMIN_ROLES=Object.freeze({OWNER:['*'],ADMIN:['tenant:read','tenant:write','keys:read','keys:write','policies:read','policies:write','webhooks:read','webhooks:write','runs:read','approvals:resolve'],OPERATOR:['runs:read','approvals:resolve','policies:read'],VIEWER:['runs:read','policies:read']});
+export function adminAuthorize(identity, permission){ const roles=Array.isArray(identity?.roles)?identity.roles:[]; return roles.some(role=>ADMIN_ROLES[role]?.includes('*')||ADMIN_ROLES[role]?.includes(permission)); }
+export function requireAdmin(identity,permission){ if(!adminAuthorize(identity,permission)){const e=new Error('Admin permission denied');e.code='AGENTGATE_ADMIN_FORBIDDEN';throw e;} return true; }