import { createFileRoute, Link } from "@tanstack/react-router"; import { Suspense, useEffect, useState } from "react"; import { useServerFn } from "@tanstack/react-start"; import { useQueryClient, useSuspenseQuery } from "@tanstack/react-query"; import { Activity, ArrowUpRight, Check, ChevronRight, Copy, Eye, Globe, Loader2, LockKeyhole, Plus, Radar, RefreshCw, Send, Shield, ShieldCheck, SlidersHorizontal, Terminal, X } from "lucide-react"; import { toast } from "sonner"; import { Button } from "@/components/ui/button"; import { Input } from "@/components/ui/input"; import { useAuth } from "@/hooks/use-auth"; import { SignIn } from "@/components/sign-in"; import { securityOverview, registerSecuritySite, verifySecuritySite, scanSecuritySite, askAegis } from "@/lib/security.functions"; import type { SecurityReport } from "@/lib/security-policy"; import shieldArt from "@/assets/aegis-shield.jpg"; import { AegisVoice } from "@/components/aegis-voice"; export const Route = createFileRoute("/security")({ head: () => ({ meta: [ { title: "Aegis — Cybersecurity | Codesynux" }, { name: "description", content: "Codesynux Aegis: website security monitoring, live header scans, verified edge status and defensive AI advice." }, { property: "og:title", content: "Aegis — Codesynux Cybersecurity" }, { property: "og:description", content: "Your dedicated cybersecurity workspace for cloud and external websites." }, { property: "og:type", content: "website" }, { name: "twitter:card", content: "summary" }, ], }), component: SecurityPage, }); function SecurityPage() { const { user, ready } = useAuth(); const [signIn, setSignIn] = useState(false); return
Codesynux / Cybersecurity
Defensive intelligence
Aegis chrome shield with emerald circuit inlays

Codesynux autonomous cybersecurity

Aegis.

A watchful eye. A stronger web.

“Trust is earned. Protection is verified.”
{!user && }
{!ready ? : user ? }> : signIn ? :
{[{ icon: Shield, title: "Your websites", text: "Sign in to discover your Codesynux deployments." }, { icon: Radar, title: "Verified observations", text: "Edge status is unknown until a domain is verified." }, { icon: Terminal, title: "Aegis intelligence", text: "Private defensive advice, powered by your Gemini connection." }].map(item =>

{item.title}

{item.text}

)}
}
; } function Loading() { return
Opening security workspace…
; } function Workspace() { const overview = useServerFn(securityOverview), register = useServerFn(registerSecuritySite), verify = useServerFn(verifySecuritySite), scan = useServerFn(scanSecuritySite), ask = useServerFn(askAegis); const qc = useQueryClient(); const { user } = useAuth(); const queryKey = ["security-workspace", user?.id]; const { data, error } = useSuspenseQuery({ queryKey, queryFn: () => overview(), staleTime: 60000, retry: false, refetchInterval: query => query.state.data?.edge.error || query.state.data?.edge.sites.some(s => s.error) ? false : 60000, refetchIntervalInBackground: false }); const [tab, setTab] = useState("overview"), [connect, setConnect] = useState(false), [domain, setDomain] = useState(""), [busy, setBusy] = useState(null); const [selected, setSelected] = useState(null), [consent, setConsent] = useState(false), [filter, setFilter] = useState("all"), [dark, setDark] = useState(6); const [text, setText] = useState(""), [messages, setMessages] = useState<{ role: "user" | "assistant"; text: string }[]>([]), [handoff, setHandoff] = useState(false); useEffect(() => { const el = document.querySelector(".security-space"); el?.style.setProperty("--bg-l", String(dark / 100)); }, [dark]); const refresh = () => qc.invalidateQueries({ queryKey }); const action = async (name: string, fn: () => Promise) => { setBusy(name); try { await fn(); } catch(e) { toast.error(e instanceof Error ? e.message : "This action could not complete."); } finally { setBusy(null); } }; const send = (prompt: string) => action("ask", async () => { const next = [...messages, { role: "user" as const, text: prompt }]; setMessages(next); setText(""); const answer = await ask({ data: { messages: next.slice(-19) } }); setMessages([...next, { role: "assistant", text: answer.answer }]); setHandoff(answer.handoff); }); const sites = [...data.cloud.map(s => ({ ...s, source: "Codesynux Cloud" })), ...data.external.map(s => ({ hostname: s.hostname, url: `https://${s.hostname}`, source: "External website" }))].filter((s,i,a) => a.findIndex(x => x.hostname === s.hostname) === i); const events = data.edge.events.filter(e => filter === "all" || e.action === filter); const report = selected ?? data.reports[0]?.report; const known = data.edge.sites.filter(s => s.proxy === true && !s.error); const copy = async (value: string) => { try { await navigator.clipboard.writeText(value); toast.success("Copied."); } catch { toast.error("Copy unavailable. Select and copy the value instead."); } }; return <>
Cloudflare {data.edge.connected ? "connected" : "unavailable"}· {new Date(data.edge.checkedAt).toLocaleTimeString()}
{(error || data.edge.error) &&

{error?.message ?? data.edge.error}

}
{[{ label: "Monitored websites", value: sites.length.toString(), detail: "Cloud + external", icon: Globe }, { label: "Proxy verified", value: known.length.toString(), detail: "Not a full security guarantee", icon: ShieldCheck }, { label: "Blocked events", value: data.edge.sites.length && data.edge.sites.every(s => !s.error && s.proxy !== null) ? data.edge.events.filter(e => e.action === "block").length.toString() : "—", detail: "Last hour · sampled events", icon: Radar }, { label: "Latest header grade", value: report?.grade ?? "—", detail: report?.hostname ?? "No scan yet", icon: Activity }].map(metric =>
{metric.label}

{metric.value}

{metric.detail}

)}
{tab === "overview" &&

Site protection manager

{sites.length} SITES
{!sites.length &&

No websites connected yet

Your published Codesynux sites appear here automatically. External domains need ownership verification.

} {sites.map(site => { const edge = data.edge.sites.find(s => s.hostname === site.hostname), external = data.external.find(s => s.hostname === site.hostname); return
{site.hostname}

{site.source}

{edge?.proxy ? "DNS proxy active" : external && !external.verified_at ? "Ownership needs verification" : "Edge protection unverified"}WAF ruleset: {edge?.waf == null ? "Unknown" : edge.waf ? "Present" : "Not found"}TLS mode: {edge?.ssl ?? "Unknown"}Rate limiting: {edge?.rateLimit == null ? "Unknown" : edge.rateLimit ? "Ruleset present" : "Not found"}
{edge?.error &&

{edge.error}

}{external && !external.verified_at &&

DNS TXT name: _codesynux.{external.hostname}

codesynux-verify={external.verification_token}
}
; })}

Monitoring does not route traffic or block attacks. External shielding requires an active Cloudflare zone and a proxied DNS record. TLS, WAF and rate-limit changes require explicit approval. A browser snippet cannot stop DDoS or protect an origin.

} {tab === "scan" &&

Live security scanner

{ e.preventDefault(); void action("scan", async () => { const result = await scan({ data: { hostname: domain, publicScanConsent: true } }); setSelected(result); await refresh(); }); }}>
setDomain(e.target.value)} />
{report ?
{report.grade}

{report.hostname}

{report.passed} passed · {report.failed} failed · score {report.score}

Observed {new Date(report.scannedAt).toLocaleString()}

HTTP security posture only — not a penetration test, SSL certificate grade, malware scan or proof of safety.

{report.findings.map(f =>
{f.pass ? : }

{f.name.replace(/-/g, " ")}

{f.result}

{!f.pass &&

{f.advice}

}
)}
:
No scan report yet.
}
} {tab === "events" &&

Live threat events

Last hour · up to 100 sampled events per verified domain · refreshes every minute while open.

{events.length ? events.map((e,i) =>
{e.action}

{e.clientRequestHTTPHost} · {e.clientIP}

{e.clientCountryName} · {e.source}

) :

No verified threat events available

Connect and verify a proxied domain to read Cloudflare events. No events does not mean no attacks.

}

SQLi, XSS and DDoS counts are not inferred from event sources; attack classification requires provider evidence.

}
{connect &&

Connect an external website

Add your domain, then verify ownership with a DNS TXT record. Verification enables status reads — it does not change traffic.

{ e.preventDefault(); void action("connect", async () => { await register({ data: { hostname: domain } }); await refresh(); setConnect(false); setTab("overview"); toast.success("Domain saved. Add the verification TXT record to continue."); }); }}> setDomain(e.target.value)} />

For edge shielding, add your website to Cloudflare and follow its nameserver setup. Keep your existing origin DNS records and enable proxy only after reviewing the impact. No generic CNAME target or Shield.js snippet is supplied because neither would create a working protection service.

} ; }