Checkers / فواحص: All 150 Checks Before You Ship
All 150 tamam checkers in one bundle, for developers, freelancers and agencies who ship code and config, their own or a client's. Each checker reads one kind of file before you ship it and lists what to fix in plain words, with the file and line. It runs locally with Python's standard library, makes no network calls and does not change your files.
What it covers:
- Code safety: Python, JavaScript and Node.js, Go, Java, Kotlin, Rust, PHP, C and C++, C#, shell and PowerShell scripts, Solidity, hardcoded secrets.
- Servers and config: nginx, Apache, Caddy, Traefik, sshd, sudoers, systemd, Redis, PostgreSQL, MySQL, MongoDB, Elasticsearch, Vault, Keycloak, and Django, Rails, Laravel, Spring Boot and ASP.NET settings.
- CI/CD and repositories: GitHub Actions, GitLab CI, CircleCI, Azure Pipelines, Jenkins, git hooks, dependency bots, .gitignore, open source licences.
- Containers and cloud: Dockerfile, Docker Compose, Kubernetes, Helm, Kustomize, Terraform, CloudFormation, Azure ARM and Bicep, AWS IAM, Argo CD, Fly.io, Vercel and Netlify, Cloudflare Wrangler.
- Payments and auth: Stripe, PayPal, Paymob, ZainCash, webhook handlers, JWT, Supabase, Firebase rules.
- Apps and stores: Android, iOS Info.plist and privacy manifests, Expo, Capacitor, Flutter, Electron, Tauri, browser extensions, Shopify apps, WordPress plugins, product feeds.
- Web, SEO and privacy: Content Security Policy, accessibility, HTML SEO, structured data, robots and sitemaps, analytics tags, personal data in logs and spreadsheets, email DNS.
- AI and agents: agent skills, AGENTS.md and CLAUDE.md rules, Claude Code settings, MCP servers, LLM apps, vector databases, model loading, llms.txt and AI crawlers.
Bought one by one they cost $750; the bundle is $49. Each checker is a lint, not a full security audit or a certificate.
كل فواحص تمام الـ150 في باقة واحدة، للمبرمجين والمستقلين والوكالات التي تسلّم كودًا وإعدادات، لنفسها أو لزبائنها. كل فاحص يقرأ نوعًا واحدًا من الملفات قبل النشر ويعرض ما يجب إصلاحه بكلام واضح مع الملف والسطر. يعمل على جهازك ببايثون فقط، بلا اتصال بالشبكة، ولا يغيّر ملفاتك.
ماذا تغطي:
- أمان الكود: بايثون، وجافاسكربت وNode.js، وGo وJava وKotlin وRust وPHP وC/C++ وC#، وسكربتات shell وPowerShell، والأسرار المكتوبة في الكود.
- إعدادات السيرفرات: nginx وApache وCaddy وsshd وsudoers وRedis وPostgreSQL وMySQL وMongoDB، وإعدادات Django وRails وLaravel وSpring Boot.
- CI/CD والمستودعات: GitHub Actions وGitLab CI وCircleCI وAzure Pipelines وJenkins وgit hooks.
- الحاويات والسحابة: Dockerfile وDocker Compose وKubernetes وHelm وTerraform وCloudFormation وAWS IAM وAzure.
- الدفع والدخول: Stripe وPayPal وPaymob وZainCash ومعالجات الويبهوك وJWT وSupabase وقواعد Firebase.
- التطبيقات والمتاجر: Android وiOS وExpo وFlutter وElectron وإضافات المتصفح وتطبيقات Shopify وإضافات WordPress.
- الويب والخصوصية: CSP، وإمكانية الوصول، وSEO، وأكواد التتبع، والبيانات الشخصية في السجلات.
- الذكاء الاصطناعي والوكلاء: مهارات الوكلاء، وملفات AGENTS.md وCLAUDE.md، وخوادم MCP، وتطبيقات LLM.
سعرها منفردة 750$، والباقة بـ49$. كل فاحص أداة تدقيق، لا تدقيق أمني كامل ولا شهادة.
Works with any agent that signs in to Agensi, such as Claude, ChatGPT, Claude Code, Cursor and Codex CLI.
One payment, lifetime access. 150 skills unlock instantly in your library.
What's included
150 skillsCheck a downloaded agent skill before you install it: credential reads plus network use, curl | bash, decoded code run with exec, SKILL.md text that works against the user, pre-approved shell access, hidden Unicode and more.
Check AGENTS.md, CLAUDE.md, GEMINI.md, Cursor, Copilot, Windsurf and Cline rules before an agent follows them: secrets, --no-verify and permission bypasses, hidden comments and Unicode, deceptive orders, curl | sh and broken rule frontmatter.
Check Apache Airflow DAGs and airflow.cfg before you deploy: credentials in DAG code, dag_run.conf in bash and SQL, exposed config and open API, secrets in airflow.cfg, Airflow 3 removals, catchup, timeouts and top-level calls.
Check tracking code before release: emails and names sent to Google Analytics, Measurement Protocol secrets in the browser, consent set after tags fire, Consent Mode v2 gaps, Universal Analytics leftovers and recordings of typed input.
Check an Android release build before you upload it: signing passwords and keystores in the repo, debuggable or debug-signed release builds, targetSdk below Google Play's API 36 rule, secrets in BuildConfig, R8 off and 16 KB page readiness.
Check AndroidManifest.xml and network_security_config.xml before a Play release: debuggable builds, cleartext HTTP, open content providers, user certificates trusted, exported components, missing android:exported, restricted permissions and unverified app links.
Check Ansible playbooks and roles before you run them: passwords outside Ansible Vault, curl | bash tasks, secrets logged without no_log, validate_certs no, 0777 modes, state latest, unpinned git checkouts and host key checking turned off.
Check Apache httpd config and .htaccess files before going live: directory listings, an open /server-status, an open forward proxy, version disclosure, TRACE, weak TLS and ciphers, CGI outside cgi-bin and PHP errors shown to visitors.
Check an iOS project before upload: required reason APIs with no declared reason, privacy manifests App Store Connect rejects, misspelled reason codes, bad tracking domains, outdated SDKs from Apple's list and manifests the target never bundles.
Check Argo CD config before you apply it: committed repository passwords and SSO secrets, anonymous access, admin as the default role, auth turned off, http repositories, wide-open AppProjects and risky sync settings.
Check an ASP.NET Core app before you deploy: connection string passwords, raw SQL built from strings, the developer exception page, open CORS with credentials, unsigned JWTs, missing HTTPS, insecure cookies, antiforgery off and debug in web.config.
Check an Astro site before you deploy: secrets in PUBLIC_ variables, vite.define or client islands, set:html with request data, CORS that echoes any origin, checkOrigin turned off, open redirects and weak session cookies.
Check AWS IAM policies before you deploy: Action "*" on Resource "*", Principal "*" open to the internet, iam:PassRole on every role, GitHub Actions OIDC roles any repository can assume, s3:* wildcards, NotAction, public buckets and cross-account trust.
Check Azure Bicep and ARM templates before you deploy: public blob storage, SSH and database ports open to the internet, secrets in templates, parameter files and outputs, open SQL firewalls, old TLS, FTP and Key Vaults without purge protection.
Check azure-pipelines.yml and its templates for secrets in YAML, commit messages or PR branch names pasted into scripts, curl | bash, retired hosted images and tasks, persistCredentials and template repos that follow a branch.
Check a browser extension before you submit: unsafe-eval or remote scripts in the CSP, eval and remote code, secrets in extension code, <all_urls> access, Manifest V2, risky permissions, open externally_connectable and trusting message listeners.
Check Bun projects before you install or deploy: http registries, tokens in bunfig.toml and .npmrc, request data in sh -c, SQL built from values, untrusted install scripts, mixed or binary lockfiles and development mode.
Check C and C++ code, Arduino sketches and CMake builds for gets(), shell commands built from input, printf(msg), scanf %s, TLS checks turned off, passwords and keys in code, weak random tokens and removed hardening flags.
Check C# and ASP.NET Core code before you deploy: SQL built from values, Process.Start with outside input, BinaryFormatter and TypeNameHandling, hard-coded secrets, trust-all TLS, weak crypto, Html.Raw, XXE, file paths and logged secrets.
Check Caddyfiles and Caddy JSON before you reload: an admin API on 0.0.0.0:2019, tls_insecure_skip_verify, file_server on home or system folders, DNS tokens in the config, tls internal on public domains and .git served.
Check Capacitor and Cordova apps before a release build: a live-reload server.url left in, WebView debugging on, mixed content, navigation to any site, passwords and keys shipped in the app, cleartext traffic and old platforms.
Check CircleCI config before you push: tokens written in the file, scripts run from http downloads, volatile and dev orbs, config CircleCI stopped compiling in September 2026, removed Xcode and machine images, and deploy contexts on every branch.
Check Claude Code settings before you commit or trust them: bypassPermissions, allow rules that run any command or curl, keys in env and hooks, hooks that pipe downloads to bash, broad file access, open WebFetch and sandbox escapes.
Check cloud-init user-data before you launch servers: plain-text passwords, SSH password login, root login, private keys and tokens, curl | bash over http, unsigned repos, risky file modes and a header cloud-init ignores.
Check Cloudflare Workers and Pages config before you deploy: secrets in vars and define, preview IDs that point at production data, staging that shares production KV, D1 and R2, workers.dev left on, and removed settings.
Check AWS CloudFormation and SAM templates before you deploy: public S3 buckets, SSH and database ports open to the internet, secrets in templates, admin IAM policies, public databases, unencrypted storage, data deleted with the stack and open Lambda URLs.
Check a PHP project's composer.json, composer.lock and auth.json: committed tokens, packages over plain HTTP, scripts that download and run code, all plugins allowed, unpinned versions, no lock file, dependency confusion and debug tools in production.
Check Content-Security-Policy headers and meta tags before you ship: script sources open to any host, unquoted keywords and typos, fixed nonces, unsafe-inline, missing object-src, base-uri and frame-ancestors, and parts browsers ignore.
Check Convex functions before you deploy: keys in code, public mutations that delete by ID with no auth check, CORS that shares cookies with any site, missing validators, api.* in crons, and queries that read whole tables.
Check CSV, TSV, JSONL and Excel files before you share them: cells that can run as formulas when opened, card numbers, IBANs, passwords and keys, emails, phone numbers and ID numbers, plus duplicates and broken rows. Never prints a cell value.
Check a dbt project before you commit: passwords and tokens in profiles.yml and package URLs, untested model keys, select * from sources, sources without freshness, hardcoded table names and incremental models without a unique_key.
Check Deno projects before you ship: -A on start and serve commands, imports over plain http, TLS checks turned off, sh -c built from variables, tokens in Dockerfiles, the lockfile turned off and unpinned remote imports.
Check Dependabot and Renovate before you trust them: registry tokens in the config, plain-HTTP registries, config the bot rejects, auto-merge workflows that trust github.actor, and automerge with no release-age wait.
Check devcontainer.json before anyone opens it: privileged containers, host commands that pipe curl into bash, secrets in env, ~/.ssh and ~/.aws mounted, the Docker socket, unpinned Features, root users, open ports and broad Codespaces access.
Check Discord bots before you run or ship them: bot tokens and webhook URLs in committed files, interactions endpoints without signature checks, eval commands, @everyone pings from user text, unchecked ban commands.
Check Django settings before you deploy: DEBUG on, SECRET_KEY in code, ALLOWED_HOSTS '*', database passwords in code, missing CSRF protection, insecure cookies, HTTPS off, CORS open to all, and weak password hashers.
Catch risky docker-compose settings before you deploy: passwords in environment, privileged containers, a mounted Docker socket, databases published to the internet, host network mode and :latest images.
Catch Dockerfile mistakes before you build or push: secrets baked into ENV or ARG, curl-pipe-to-shell downloads, copied .env files and keys, root containers and unpinned base images.
Check Drizzle ORM projects before you deploy: sql.raw() built from requests, database passwords in drizzle.config or code, drizzle-kit push --force in deploy scripts, delete without where, float money columns and unindexed foreign keys.
Check elasticsearch.yml, kibana.yml, opensearch.yml, opensearch_dashboards.yml and Compose services for security off on reachable nodes, passwords in files, OpenSearch demo certificates, open CORS and missing HTTPS.
Check an Electron app before you ship it: nodeIntegration on, contextIsolation or webSecurity off, ipcRenderer exposed to pages, sandbox off, pages over HTTP, no navigation limits, unchecked shell.openExternal, no CSP and old Electron versions.
Check DNS zone files and exports for SPF, DKIM and DMARC mistakes: missing or duplicate SPF, +all and ?all, over 10 lookups, no DMARC or p=none, no rua, short or broken DKIM keys, MX pointing to an IP or CNAME. No DNS lookups.
Check HTML email templates before a campaign: missing unsubscribe links, emails Gmail will clip, http and javascript links, missing alt text and preheaders, wide layouts, no postal address, vague links and broken merge tags.
Keep .env.example in step with your code and keep .env files out of git: missing and stale variables, real secrets in the example file, unignored .env files and secrets with public prefixes.
Check Expo and EAS projects before you build, submit or publish an update: secrets in EXPO_PUBLIC_ variables, app config and eas.json, credentials.json outside .gitignore, dev builds in release profiles and unsafe over-the-air updates.
Check a FastAPI app before you deploy: hard-coded secret and JWT keys, unverified JWTs, SQL from f-strings, CORS * with credentials, public /docs, debug and reload, weak password hashing, tokens without expiry and leaked exception text.
Check Firestore, Storage and Realtime Database security rules before you deploy: writes open to everyone, a catch-all rule that opens the whole database, leftover test-mode rules, any-user writes, public reads and unlimited uploads.
Check a Flask app before you deploy: debug mode, a hard-coded SECRET_KEY, render_template_string injection, SQL from f-strings, file paths from requests, open CORS, |safe, insecure cookies, CSRF off, open redirects and unsafe uploads.
Check Flutter apps before release: secrets compiled into the APK, badCertificateCallback returning true, http:// servers, tokens in shared_preferences or logs, unpinned git packages, WebView bridges and .env files in assets.
Check fly.toml before you deploy to Fly.io: secrets in [env] and build args, databases on public ports, statics that serve your source, HTTPS not forced, missing health checks, port mismatches and settings Fly rejects.
Check pre-commit, lefthook and husky hook setups: hook repos over plain HTTP, branch revs, hooks that pipe curl into a shell, tokens in hook files, unpinned hook tools, and secret scanners that are missing or skipped.
Find the GitHub Actions mistakes that let a pull request or issue run code with your secrets: pull_request_target misuse, script injection, hard-coded tokens, unpinned actions and broad permissions.
Check that .env files, private keys, key stores, tokens and Terraform state stay out of git, Docker images and npm packages, and that node_modules, build output, logs and editor junk are ignored.
Check .gitlab-ci.yml before you push: tokens in variables, curl | bash installs, secrets echoed to job logs, .env files or keys kept as artifacts, :latest images, unpinned includes and production deploys that any branch can run.
Check Go code before you deploy: SQL built with Sprintf or +, shell commands from variables, hard-coded secrets and JWT keys, JWT none, InsecureSkipVerify, math/rand tokens, weak password hashes, servers without timeouts and pprof.
Check Grafana and Prometheus config before going live: admin/admin, anonymous Admin access, data source passwords in provisioning files, default secret_key, open sign-up, auth proxy without a whitelist, TLS checks off.
Check GraphQL servers and schemas before you deploy: introspection forced on, password hashes and API keys on output types, no depth limits, GraphiQL in production, CSRF off, stack traces, unpaginated lists and batching.
Check HAR files before you send them to support or commit them: session cookies, Authorization headers, tokens and signatures in URLs, passwords in post data, tokens in response bodies, emails, phone numbers and internal hosts.
Find API keys, tokens, private keys and database passwords in a project before you commit, publish or zip it: 18 providers by their real key formats, plus whether .gitignore keeps each file with a secret out of git.
Check Helm charts before you publish or install them: passwords in values and templates, privileged pods, host mounts, :latest images, root containers, no memory limits, unpinned or http dependencies, open LoadBalancers and ingresses.
Check a Home Assistant config before you share, commit or expose it: passwords written inline instead of !secret, secrets.yaml outside .gitignore, open trusted proxies and trusted networks, open webhooks and templated shell commands.
Check Hono APIs before you deploy: CORS that echoes any origin with credentials, auth secrets in code or Wrangler vars, request data in raw() or c.html(), SQL built from requests, open redirects, missing csrf() and more.
Check web pages for WCAG accessibility failures before you publish: images without alt text, fields without labels, icon buttons with no name, missing page language, clickable divs, zoom turned off, skipped headings, autoplay sound and removed focus outlines.
Check your site's HTML before launch for the SEO basics: noindex left on, titles, meta descriptions, H1s, image alt text, lang, viewport, canonical, Open Graph and duplicate titles.
Check an iOS app's Info.plist, .xcconfig and .entitlements before App Store review: ATS turned off, plain-HTTP and TLS 1.0 exceptions, API secrets, AuthKey .p8 files in the project, weak permission texts, get-task-allow and file sharing.
Check Java and Spring Boot code before you deploy: SQL built with + or format, Runtime.exec and ProcessBuilder with outside input, unsafe deserialization, hard-coded secrets and JWT keys, XXE, weak crypto, trust-all TLS and logged secrets.
Check Jenkins pipelines before they run: credentials in double-quoted sh steps, secrets in the Jenkinsfile, PR titles and text parameters in shell commands, code on the controller, curl -k, curl | bash, unpinned libraries and open approvals.
Check .ipynb notebooks before you share or commit them: keys in cells, secrets saved in outputs and metadata, emails and phone numbers in outputs, unpinned installs, curl | bash, huge outputs, home-folder paths and cells run out of order.
Check JWT login and API auth code before you ship: tokens read without a signature check, the none algorithm, hard-coded secrets, missing expiry, tokens in localStorage or URLs, weak cookies and flawed JWT library versions.
Check Keycloak realm exports and server config before you import or deploy: wildcard redirect URIs, sslRequired none, client secrets and signing keys in exports, literal admin passwords, start-dev in deployments and weak login settings.
Check Android Kotlin and Java code before release: WebView JavaScript bridges on remote pages, onReceivedSslError proceed(), trust-all TLS, keys in the APK, tokens in SharedPreferences and logs, mutable PendingIntents.
Check Kubernetes YAML before kubectl apply: privileged pods, passwords in env, Secret manifests in git, Docker socket hostPath mounts, host network, root containers, missing memory limits and exposed databases.
Check kustomization.yaml bases and overlays before you deploy: secrets in generators and inline patches, committed secret env files, remote bases with no ref, unpinned charts and images, deprecated fields, and overlays with no namespace.
Check a Laravel app before you deploy: APP_DEBUG on in production, a sample or short APP_KEY, passwords hardcoded in config files, a .env inside public/, insecure session cookies, CORS '*' with credentials, Telescope on and weak database settings.
Check code that calls OpenAI, Anthropic, Gemini, LangChain or the Vercel AI SDK: API keys in code or the browser, model output run as code or SQL, user input in system prompts, no token limits, logged prompts, raw HTML and risky agent tools.
Check llms.txt and the AI crawler rules in robots.txt before you publish: missing H1, localhost or staging links, pages robots.txt blocks for every AI crawler, several bots on one User-agent line, misspelled bot names.
Check Maven and Gradle builds before you release: http:// repositories and allowInsecureProtocol, passwords in build files and gradle.properties, wrappers from mirrors without checksums, dynamic and SNAPSHOT versions, mavenLocal() and jcenter().
Check MCP server configs for Claude Code, Cursor, VS Code, Claude Desktop, Windsurf, Cline and Gemini CLI: keys in env or headers, plain http servers, curl | bash, Docker socket mounts, unpinned npx/uvx packages and auto-approved write tools.
Check MCP server code before you publish or install it: tool arguments in shell commands, eval, hard-coded keys, poisoned tool descriptions, file paths and URLs from arguments, open HTTP transports, stdout in stdio servers and SQL from strings.
Check RabbitMQ, Mosquitto, Kafka and NATS configs before a broker goes live: anonymous clients on network listeners, guest opened to remote hosts, passwords in the config, plain-text listeners and exposed management ports.
Check Python ML code and notebooks before you load models: pickle, joblib and torch.load on downloaded files, unpinned trust_remote_code, model downloads over http, Hugging Face tokens in code, unpinned Hub downloads and torch below 2.6.
Check a MongoDB setup before it goes live: a server open without authentication, passwords in connection strings and compose files, NoSQL injection, no TLS, authorization disabled, port 27017 open to all and certificate checks off.
Check MySQL and MariaDB config before going live: skip-grant-tables, passwords in my.cnf and compose files, an empty root password, local_infile, an open bind-address without TLS, TLS 1.0, the general log and port 3306 open to all.
Check n8n workflow exports before you share or commit them: tokens pasted into nodes instead of credentials, commands and SQL built from webhook data, open webhooks, decrypted credential exports, and secrets or customer data left in pinned data.
Check NestJS apps before you deploy: TypeORM synchronize, hard-coded JWT secrets, SQL built with template strings, ValidationPipe gaps, open CORS, missing helmet and rate limits, exposed Swagger and auth guards that let requests through.
Check a Next.js app before you deploy: secret keys in NEXT_PUBLIC_ variables or next.config env (sent to every browser), a weak NEXTAUTH_SECRET, public source maps, ignored build errors, an open image proxy and risky NextAuth options.
Check nginx config before you reload: directory listings, TLS 1.0/1.1, the alias off-by-slash path traversal, proxy_pass to a host from the request, missing HSTS and security headers, weak ciphers and an open status page.
Check Node.js API code before you merge: SQL built with template literals, child_process exec with user input, eval, hardcoded JWT and session secrets, CORS open with credentials, weak JWT checks, TLS checks off, open redirects and Math.random tokens.
Check package.json and .npmrc for supply-chain risks: install scripts that download code, http dependencies, leaked registry tokens, wildcard versions, git dependencies and missing lockfiles.
Check NuGet.config and .NET project files before restore: http package sources, feed tokens in plain text, TLS checks turned off, floating and prerelease versions, unmapped sources (dependency confusion), missing lock files and NuGetAudit off.
Check Nuxt and Vue apps before you deploy: secrets in runtimeConfig.public, NUXT_PUBLIC_ or app.config, literal secrets in nuxt.config, v-html XSS, open redirects, client source maps, CORS with credentials and exposed tokens.
Check your project and its installed npm, Python and Composer dependencies for AGPL and SSPL in closed-source code, non-commercial and BUSL licenses, GPL obligations, unknown licenses, and missing or invalid license fields. Not legal advice.
Check OpenAPI and Swagger specs before you publish: write endpoints with no auth, plain http servers, real keys in examples, API keys in query strings, OAuth implicit and password flows, Basic auth and tokens in URLs.
Check OpenTelemetry Collector configs, Helm values and OTEL_* settings before you deploy: vendor keys in headers, keys sent without TLS, pipelines that stop the Collector starting, open receivers and risky defaults.
Catch Paymob integration mistakes before real payments: leaked secret keys, callbacks trusted without an HMAC check, the wrong HMAC fields, and amounts that are not whole cents.
Check PayPal checkouts before you go live: client secrets in the browser or in code, order amounts taken from the request, browser captures your server trusts, unverified webhooks and IPN, sandbox in production and deprecated SDKs.
Check PHP code before you deploy: SQL injection in mysqli, PDO and $wpdb queries, command injection, eval, include of request values, unserialize on cookies, hard-coded passwords, unescaped echo of $_GET (XSS), md5 passwords and open redirects.
Check logging calls and settings before they ship: passwords, tokens, connection strings, Authorization headers and card numbers in logs, login bodies, emails and ID numbers, whole user objects, DEBUG in production, Sentry PII.
Check pnpm-workspace.yaml, .npmrc, package.json and pnpm-lock.yaml before you install: install scripts allowed for all, committed registry tokens, http registries, TLS off, the release delay off, and settings pnpm 11 no longer reads.
Catch risky Postgres migrations before they lock a table or delete data. Get PASS, REVIEW, or BLOCK with the exact statement, the reason, and a safer approach.
Check a self-hosted PostgreSQL server before it goes live: trust logins in pg_hba.conf, cleartext and MD5 passwords, rules open to every address, remote superuser logins, fsync off, listening without SSL, and POSTGRES_HOST_AUTH_METHOD=trust in Docker.
Check Postman, Insomnia and Bruno collections and environments before you share or commit them: saved tokens and passwords, secret variables with real values, live API keys, http://, strictSSL off, risky scripts and saved sessions.
Check PowerShell scripts before you run or ship them: iex of variables, irm | iex, secrets in scripts, Remove-Item -Recurse on "$dir\*" with an empty dir, Bypass execution policy, TLS checks off, http downloads and unpinned modules.
Check Prisma projects before you ship: database passwords in the schema or prisma.config.ts, $queryRawUnsafe built from strings, migrate reset or db push --accept-data-loss on deploy, req.body passed as data, and schema mistakes.
Check Google Shopping product feeds before you upload: missing required attributes, prices not written like 15.00 USD, wrong availability values, duplicate ids, broken links and rows, bad GTINs, promotional titles and apparel gaps.
Check promptfoo eval and red team configs before they reach CI: written-in API keys, file:// paths that do not exist, keys sent over plain http, evals that cannot fail, unpinned graders, sharing on and duplicate tests.
Check PWA manifests, service workers and Workbox configs: broken manifest JSON, start_url outside scope, cached session or account data, importScripts and respondWith mistakes, install-prompt gaps, and risky cache and update settings.
Check Python code before you merge: SQL built from strings, pickle and yaml.load on untrusted data, eval and exec, hardcoded secrets, verify=False, unverified JWTs, MD5 on passwords, debug mode, mktemp and random tokens.
Check pyproject.toml and uv, Poetry, PDM, Hatch and Pipenv config before you install or publish: http indexes, tokens in index URLs, TLS checks off, private indexes merged with PyPI, branch git deps and missing lock files.
Check requirements.txt for supply-chain risks: http package indexes, tokens in index URLs, --trusted-host, --extra-index-url dependency confusion, unpinned versions, git branches and URLs without hashes.
Check a Rails app before you deploy: production secrets, master.key in git, SQL built from params, permit!, shell commands and eval with request data, full error pages, missing force_ssl, CSRF off, html_safe, open redirects and open CORS.
Check a React front end before you ship: dangerouslySetInnerHTML without DOMPurify, redirects to ?next= values, secrets in VITE_ and NEXT_PUBLIC_ variables, eval, tokens in localStorage, innerHTML, postMessage to * and public source maps.
Check redis.conf before a server goes live: Redis open to the network with no password, the sample password foobared, dump files written to a web root or .ssh folder, CONFIG and FLUSHALL open to clients, no TLS, and debug or module commands on.
Check a repository before you push or publish it: merge conflict markers, files over GitHub's 100 MiB limit, CRLF shell scripts, names that break clones on Windows and macOS, and keys, env files and dumps that git still tracks.
Check Roblox Luau code before you publish: remotes that trust a client's price or amount, loadstring and require(assetId) backdoors, webhooks and keys in scripts players can read, DataStore calls without pcall, unfiltered text.
Check robots.txt and sitemap.xml before launch: a site blocked with Disallow /, localhost or staging URLs, invalid sitemap XML, blocked CSS and JS, misspelled rules, bad lastmod dates and sitemap pages that robots.txt blocks.
Check Ruby Bundler files before you install or deploy: gem sources over http://, passwords in source URLs and .bundle/config, git gems on a branch, several global sources, no committed Gemfile.lock and gem checksum checks turned off.
Check Rust projects before you build or release: git dependencies that follow a branch, crate sources over http, registry tokens in Cargo files, wildcard versions, [patch] overrides, a missing Cargo.lock, risky build.rs and every unsafe block.
Check Ollama, vLLM, llama.cpp, LocalAI, TGI, LiteLLM and Open WebUI configs before you expose them: open model APIs with no key, keys in config, Open WebUI with logins off or admin sign-up, remote code and moving image tags.
Check serverless.yml before you deploy: secrets in environment, custom or ${file()} includes, IAM * on *, routes without an authorizer, CORS *, deprecated Lambda runtimes, public function URLs and timeouts longer than API Gateway waits.
Check bash and sh scripts before you run or ship them: eval of variables, secrets in scripts, rm -rf "$DIR/"* with an empty DIR, curl | bash, unquoted rm and cp, curl -k, chmod 777, fixed /tmp files, set -x with secrets and unchecked cd.
Check Shopify apps before you deploy: tokens and client secrets in files, Admin tokens in VITE_ or NEXT_PUBLIC_ variables, unverified webhooks and app proxy requests, weak OAuth checks, compliance webhooks, scopes, retired API versions.
Check Slack apps before you deploy: tokens, signing secrets and webhook URLs in code, env and CI files, Events API and slash command endpoints with no signature check, Bolt checks turned off, admin scopes and @channel posts with user text.
Check Solidity contracts before you deploy: tx.origin auth, delegatecall to caller addresses, open selfdestruct and initializers, reentrancy, floating pragmas, unchecked calls, weak randomness and missing access control. Not an audit.
Check Spring Boot application.properties and application.yml before you deploy: hardcoded secrets, Actuator heapdump and env exposed, H2 console on, ddl-auto create-drop, stack traces in errors, and other risky settings.
Check sshd_config before you reload SSH: root login, empty passwords, password logins that still work through PAM, SSH private keys in the project, weak ciphers and ssh-rsa keys, public GatewayPorts and logging turned down.
Check Streamlit and Gradio apps before you deploy: secrets.toml that git would commit, user input rendered as HTML or run with eval, Gradio paths that expose the disk, API keys in code, public launches without login.
Check a Stripe integration before you go live: live keys in code, secret keys in browser code, webhooks with no signature check, payment amounts set by the client, missing idempotency keys, raw card numbers on your server, and Checkout orders fulfilled before payment.
Check schema.org JSON-LD before you publish: broken JSON, properties Google requires for rich results, misspelled types, prices with $ signs, non-ISO dates, relative URLs, bad ratings, and FAQ or How-to markup Google no longer shows.
Check sudoers files before they reach a server: NOPASSWD ALL, passwordless vim, less, git, find or docker, wildcards in commands, scripts in /home or /tmp, env_keep LD_PRELOAD, !authenticate, no secure_path, rules for ALL users.
Check Supabase projects before you deploy: service keys in NEXT_PUBLIC_ or VITE_ variables, secrets in config.toml, redirect wildcards that accept any site, open Edge Functions using the service key, and weak auth settings.
Check Supabase migrations before you push: public tables without row level security, policies that let anyone write, views that bypass RLS, policies that trust user_metadata, and service_role keys in SQL.
Check SvelteKit 2 and 3 apps before you deploy: secrets in PUBLIC_ variables or returned from load, CSRF checks turned off, CORS that trusts any origin, {@html} XSS, open redirects, weak session cookies and inline-script CSP.
Check systemd unit files before you install them: passwords in Environment=, programs run from /tmp, apps running as root with no sandboxing, missing hardening, CAP_SYS_ADMIN, and curl | bash run at every start.
Find what breaks or quietly changes when a project moves to Tailwind CSS v4: the old PostCSS plugin and CLI, @tailwind directives, an unloaded tailwind.config.js, removed bg-opacity classes, @apply without @reference, changed defaults.
Check Tauri 1 and 2 apps before release: allowlist all, shells the webview can run, file scopes over the home folder, a missing CSP, remote sites calling commands, leaked signing keys and unsafe updater settings.
Check Telegram bots and Mini Apps before you deploy: bot tokens in code, webhooks without a secret token, unchecked Mini App initData, chat text run as code, unguarded admin commands, unescaped HTML, tokens in logs and blind payment approvals.
Check Terraform before plan or apply: hardcoded secrets, SSH or database ports open to 0.0.0.0/0, public buckets, state files in git, public databases, wildcard IAM policies and unpinned modules.
Check Traefik before you expose it: api.insecure, dashboards with no login, insecureSkipVerify, tokens in labels and files, exposedByDefault, HTTP with no redirect, the Docker socket in Traefik, TLS 1.0, debug logs and header logging.
Check translation files before a language ships: placeholders that differ from the base, files that will not load, broken ICU plurals, apostrophes that hide {0}, and missing or untranslated keys in JSON, YAML, .po, .arb, .strings and Android XML.
Check Turborepo and Nx monorepos before a cache leaks a secret or skips a deploy: .env files in outputs, cached deploy and migrate tasks, committed cache tokens, undeclared env vars, unsigned self-hosted caches and deprecated Nx caches.
Check HashiCorp Vault configs, ACL policies and the files that run Vault: TLS off on network listeners, dev servers in deployments, all-paths policies, tokens and unseal keys in files, escalation grants and settings Vault 2.x rejects.
Check Qdrant, Weaviate, Chroma and Milvus setups before you deploy: open databases behind load balancers, auth settings the server ignores, keys in Compose, Helm and code, the default Milvus root password, open ports and plain HTTP.
Check vercel.json, netlify.toml, _headers and _redirects before you deploy: keys in env and build settings, CORS with credentials for any origin, open redirects built from the request, missing or weak security headers and http:// targets.
Check Vite projects before you build or share a dev server: secrets in VITE_ variables, a risky envPrefix, define copying process.env into the bundle, file guards turned off, servers on all interfaces, source maps and open CORS.
Find what slows LCP and makes pages jump in HTML, templates, React, Vue, Svelte, Astro and CSS: lazy hero images, broken preloads, sync head scripts, fonts without font-display, unsized images, heavy images and embeds.
Check webhook endpoints for GitHub, Shopify, Twilio, Paddle, Clerk, Razorpay and 9 more providers: missing signature checks, secrets in code, checks that fail open, == comparisons, HMACs over parsed JSON, replays and duplicate events.
Check wp-config.php before a site goes live: sample keys and salts, PHP errors shown to visitors, a public debug.log, wp-config.php.bak copies, the dashboard code editor, and weak database and update settings.
Check WordPress plugins and themes before you release: $wpdb queries built from $_GET, AJAX and admin-post handlers without nonces or capability checks, open REST routes, unescaped output, unserialize of request data and readme.txt problems.
Catch ZainCash payment mistakes before real money moves: redirect and webhook tokens trusted without a signature check, leaked client secrets and API keys, wrong currency, decimal dinars, and unchecked refunds.
See it in action
Agent Skill Safety Check
Example session with this skill installed
Check this project with agent-skill-safety-check.
- Read your context and instructions
- Compiled the agent safety check
$ python3 scripts/check_skill.py examples/risky
BLOCK meeting-notes-sync/SKILL.md:4 K05 ALLOWED_TOOLS_ANY_COMMAND
allowed-tools: Read Write Bash
Why: The allowed-tools field in the SKILL.md frontmatter pre-approves tools, so the agent uses them with no permission prompt while the skill is active (in Claude Code, for the turn that invokes the skill). Here it pre-approves every shell command (Bash, Bash(), PowerShell) or a shell, interpreter, downloader or sudo (Bash(python3:), Bash(curl *)), so the skill's own steps can run any command without the user seeing a prompt.
Safer: Pre-approve only the exact commands the skill needs, scoped to its own scripts (for example Bash(python3 ${CLAUDE_SKILL_DIR}/scripts/run.py *)), or remove allowed-tools and let the agent ask as usual.
BLOCK meeting-notes-sync/SKILL.md:22 K02 DOWNLOAD_AND_RUN
BLOCK meeting-notes-sync/SKILL.md:23 K02 DOWNLOAD_AND_RUN
BLOCK meeting-notes-sync/SKILL.md:32 K04 OVERRIDES_USER_OR_SAFETY
BLOCK meeting-notes-sync/SKILL.md:34 K04 OVERRIDES_USER_OR_SAFETY
BLOCK meeting-notes-sync/scripts/setup.sh:10 K03 OBFUSCATED_CODE_RUN
BLOCK meeting-notes-sync/scripts/sync.py:23 K01 SECRETS_READ_AND_SENT
BLOCK meeting-notes-sync/scripts/sync.py:24 K01 SECRETS_READ_AND_SENT
BLOCK meeting-notes-sync/scripts/sync.py:33 K03 OBFUSCATED_CODE_RUN
BLOCK meeting-notes-sync/scripts/sync.py:38 K02 DOWNLOAD_AND_RUN
REVIEW env-report/scripts/show_env.py:7 K18 READS_CREDENTIALS
REVIEW meeting-notes-sync/SKILL.md:2 K15 FRONTMATTER_INVALID
REVIEW meeting-notes-sync/SKILL.md:5 K17 RUNS_COMMANDS_ON_LOAD
REVIEW meeting-notes-sync/SKILL.md:22 K12 NETWORK_USE
REVIEW meeting-notes-sync/SKILL.md:27 K17 RUNS_COMMANDS_ON_LOAD
REVIEW meeting-notes-sync/scripts/setup.sh:9 K13 WRITES_OUTSIDE_PROJECT
REVIEW meeting-notes-sync/scripts/setup.sh:11 K11 DESTRUCTIVE_COMMAND
REVIEW meeting-notes-sync/scripts/sync.py:17 K16 OPAQUE_CONTENT
REVIEW meeting-notes-sync/scripts/sync.py:29 K12 NETWORK_USE
REVIEW meeting-notes-sync/scripts/sync.py:42 K11 DESTRUCTIVE_COMMAND
REVIEW meeting-notes-sync/scripts/sync.py:47 K13 WRITES_OUTSIDE_PROJECT
(Each finding also has Why and Safer lines, as in the first one.)
Verdict: BLOCK. Checked 5 files, 5 with agent skill content.
This is a static check of file text. NOT FLAGGED is not a guarantee.
How to use
- 1
Connect your agent to the Agensi MCP
Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup
- 2
Sign in to Agensi
Your agent shows a sign-in link. Sign in and click Allow.
- 3
Ask for what you need
Your agent loads these skills and uses them on your task. It always asks before buying a skill.
Reviews
No reviews yet
Be one of the first to try it. Every skill in this bundle goes through our trust checks.
Security scanned
Checked by our 8-point scan before listing
Fresh listing
Recently published to Agensi
Money-back guarantee
Doesn't do what its page promises? You get your money back.