docs: add OpenClaw security roadmap article

Author: steipete

public/blog/authors/jesse-merhi.jpg

@@ -3,7 +3,9 @@ import { glob } from 'astro/loaders';
 
 const authorSchema = z.object({
   name: z.string(),
-  handle: z.string(),
+  handle: z.string().optional(),
+  url: z.string().optional(),
+  avatar: z.string().optional(),
 });
 
 const blog = defineCollection({
@@ -15,6 +17,8 @@ const blog = defineCollection({
     // Single author (legacy)
     author: z.string().optional(),
     authorHandle: z.string().optional(),
+    authorUrl: z.string().optional(),
+    authorAvatar: z.string().optional(),
     // Multiple authors
     authors: z.array(authorSchema).optional(),
     draft: z.boolean().default(false),

src/content.config.ts

@@ -0,0 +1,143 @@
+---
+title: "Where OpenClaw Security Is Heading"
+description: "The security roadmap for making OpenClaw a powerful personal assistant runtime users can understand, observe, and trust."
+date: 2026-05-15
+authors:
+  - name: "Jesse Merhi"
+    url: "https://www.linkedin.com/in/jesse-merhi/"
+    avatar: "/blog/authors/jesse-merhi.jpg"
+draft: false
+tags: ["security", "open-source", "clawhub", "plugins"]
+---
+
+Our goal is for OpenClaw to become a trusted way to run a powerful AI personal assistant.
+
+That sounds simple, but it flips how people often talk about agent runtimes. OpenClaw can read files, run commands, install plugins, talk to the network, and act on a real machine for a real user. Power like that is easy to describe as dangerous.
+
+The concern is not wrong. We want OpenClaw to be powerful enough to do real work. That is the point. But powerful does not have to mean blind, unbounded, or impossible to audit.
+
+This is where our security work is heading.
+
+Some of this has landed. Some is rolling out. Some is still in flight. Some is research. I want to be clear about the difference, because security posts that blur those lines are usually where trust goes to die.
+
+## Filesystem Handling, Runtime State, and fs-safe
+
+**Status: landed for the shared filesystem primitives; in flight for the larger runtime-state move.**
+
+OpenClaw runs on your machine. That means it can touch your documents, your codebases, and your photos.
+
+The filesystem risk people usually reach for first is path traversal. That risk is real, but it is also only one symptom of a bigger class of bugs: unclear boundaries. Code thinks it is writing inside one root, then a symlink, absolute path, archive extraction, or sloppy join makes it cross another.
+
+`fs-safe` is one answer to that. It is not a new idea bolted onto OpenClaw from the outside. It is the set of safe filesystem patterns OpenClaw had already been growing, pulled into a shared library so core code, plugins, and adjacent services can use the same root-bounded primitives.
+
+It is also not a sandbox. A plugin that is allowed to run arbitrary shell commands can still do arbitrary shell-command things. We should say that plainly. `fs-safe` protects against boundary-crossing bugs in filesystem code. It does not turn untrusted code into trusted code.
+
+That distinction matters. Writing inside a plugin workspace should work. Traversal and absolute-path writes outside that workspace should fail. Plugin authors should not have to reimplement those checks, and reviewers should not have to rediscover every edge case in every package.
+
+The next step is making these primitives the expected pattern for plugins on ClawHub too. Bypassing them is not automatically malicious, but it is security-relevant. Over time, that kind of choice should count against a plugin's trust posture.
+
+The safest filesystem call is still the one we do not make. That is the security motivation behind the in-flight SQLite runtime-state refactor. Runtime state should not sprawl across loose files when it can live in a typed database with clearer ownership, transactions, and recovery behavior.
+
+Sessions, transcripts, scheduler state, and plugin state are all areas where we want less ad hoc file handling. `fs-safe` makes required filesystem access safer. Moving runtime state into a database removes whole categories of filesystem access from the runtime path.
+
+## SSRF, Network Egress, and Proxyline
+
+**Status: rolling out as a Node-process egress guardrail.**
+
+The network problem is also a boundary problem.
+
+Agentic systems make SSRF harder than it is in a normal web service. In a normal service, user-controlled URLs are often the exception. In an agent runtime, user-controlled or model-influenced URLs are normal product behavior. "Fetch this URL because someone, or something, asked for it" is not an edge case. It is a feature.
+
+We started with the obvious approach: validate the URL before fetching it. Resolve DNS, check the address, then let the request go out.
+
+That is not enough.
+
+The validation code resolves DNS. The actual fetch resolves DNS again. Between those two moments, the answer can change. A host that pointed at a public IP during validation can point at a metadata endpoint by the time the request leaves.
+
+The fix has to move closer to egress.
+
+Proxyline is our Node-process routing layer for that. It is not itself the filtering proxy. It installs process-global routing for Node networking surfaces and sends traffic through the proxy you configured. The configured proxy is where the connect-time policy should live: block metadata addresses, private ranges, loopback canaries, and whatever else your environment needs blocked.
+
+That split is important. Proxyline routes. The proxy enforces.
+
+It also gives operators observability. If you already run a managed proxy, you can route OpenClaw through it and watch destinations, rates, and blocked attempts from infrastructure you already trust.
+
+Proxyline is not a perfect cage around every possible byte. Raw sockets, native modules, unusual transports, early-captured agents, and non-OpenClaw child processes can still bypass a Node-level guardrail. We are not going to pretend otherwise. But for ordinary OpenClaw network paths, moving the control point from "a wrapper remembered to validate this URL" to "egress flows through a proxy policy" is a much better shape.
+
+The validation path is simple: `example.com` should pass, a loopback canary should fail, and `openclaw proxy validate` should prove the configured route behaves that way.
+
+## ClawHub Trust, ClawScan, and Plugin Provenance
+
+**Status: landed for ClawHub-hosted package trust signals; still evolving for tiers and off-Hub packages.**
+
+For a while, we tried to secure plugins mostly inside OpenClaw itself. That will never be enough.
+
+ClawHub has to be the authority for plugin trust and provenance when a plugin comes from ClawHub. OpenClaw should consume those signals during install and update, not rely only on local inspection after the fact.
+
+The ClawHub pipeline is a mix of signals: ClawScan, VirusTotal, static analysis, metadata checks, source provenance, and manual moderation. None of those is magic. Scanners are noisy in different ways, and a pipeline that screams about everything teaches users to ignore it.
+
+So the hard work is calibration. Which signal is reliable? Which one false-positives? Which findings should block an install, and which should be shown as evidence without becoming a verdict?
+
+That is where ClawHub can do something a local install flow cannot. It can attach trust evidence to a specific package version. It can say this release is clean, suspicious, held, quarantined, revoked, or malicious. It can block downloads for malicious or quarantined releases. It can show users what changed and why.
+
+Not every OpenClaw plugin will live on ClawHub. Plugins can come from GitHub, a private registry, or a file someone sends you. That is not going away, and OpenClaw should not pretend users do not own their own machines.
+
+What we can do is make the safe path better. Publish on ClawHub. Get scanned. Attach evidence. Let users weigh that evidence before install.
+
+We are also exploring higher-trust tiers above the baseline: official packages, trusted publishers, and packages held to stricter review expectations. For plugins that live outside ClawHub, we want scanning to reach them too, but the exact product shape still needs work.
+
+If ClawHub marks `@openclaw/kitchen-sink@0.1.0` as malicious and quarantined, the ClawHub install path should refuse it. That is the bar.
+
+## Command Authorization and Prompt Fatigue
+
+**Status: landed for stronger shell allowlist analysis; experimenting on contextual approval.**
+
+Anyone who has used an agent harness in approval mode knows the pain.
+
+Prompts arrive faster than anyone can read them. After a few minutes, users flip on YOLO mode so work can continue. At that point the prompts are not protecting anyone. They trained the user to stop reading.
+
+Fixing this means fewer prompts, and better prompts.
+
+The accuracy part starts with parsing. String matching is not enough. If an allowlist or blocklist only sees the outer command, wrappers become a bypass. A policy that understands `rm` but cannot see inside `bash -c "rm -rf ~/something"` is not a policy users should trust.
+
+OpenClaw has been pushing on that. The shell approval path now evaluates inner command chains for common shell `-c` wrappers. If the inner chain contains an executable that is not allowed, the wrapper should not make it safe. The command highlighter also uses Tree-sitter to show users what OpenClaw found, including executables inside wrapper payloads.
+
+PowerShell has its own shape and its own traps. We already fail closed for forms we do not understand, and broader PowerShell support is on the roadmap.
+
+Parsing is the easier half. The harder half is deciding when to ask.
+
+A static approval policy tends to do one of two bad things. It prompts on everything that might be risky, which sends users to YOLO mode. Or it relies on a fixed allow/deny list that cannot tell whether a command fits the current task.
+
+The question users actually care about is simpler: did I want this to happen?
+
+That is why we are experimenting with contextual approval. The goal is not "never prompt." The goal is that prompts mean something. If OpenClaw asks, the user should stop and read. If OpenClaw does not ask, that decision should be one we can defend.
+
+## Static Analysis
+
+**Status: landed and running on PRs.**
+
+OpenClaw has had a lot of GitHub Security Advisories. That means we have patched a lot of security bugs.
+
+The first job was plugging holes. The next job is making sure the same bug class does not come back.
+
+After an advisory is patched, it is tempting to call it done. We should not. A GHSA is evidence about a bug class, not just one bug. The question after triage is: can we find all the code that looks like this?
+
+For that, we use OpenGrep with a precise rulepack. Each rule is tied to an advisory, report, or review finding. The baseline goal is regression detection: if the same vulnerable shape returns, CI catches it before review does. The better goal is variant detection: catch nearby versions of the same mistake.
+
+Precision is everything. A noisy rule is worse than no rule, because it teaches the team to ignore the channel.
+
+Today the checked-in precise OpenGrep rulepack has 148 rules. It runs on PR diffs, and the full scan can be run manually. New patched advisories become candidates for new rules.
+
+CodeQL covers broader ground alongside it. The challenge there is scale. OpenGrep can scan our focused rulepack quickly. CodeQL gives deeper semantic coverage but takes more time and cleanup. We need both.
+
+## What This Means for OpenClaw Users
+
+OpenClaw is not becoming less powerful. That would miss the point.
+
+It is becoming more legible. More observable. More explicit about which boundary is being enforced where.
+
+`fs-safe` does not sandbox plugins; it prevents filesystem boundary mistakes. Proxyline does not replace a filtering proxy; it routes Node egress through one. ClawHub does not remove user choice; it gives users package-version evidence before install. Command authorization does not work because prompts exist; it works when prompts are rare enough and accurate enough to matter.
+
+We are not going to promise risk-free agents. Anyone promising that is selling something, or has not shipped enough yet.
+
+What we can promise is the direction. OpenClaw can stay powerful while becoming more defensible. That is the runtime we want to build, and the runtime personal assistants deserve to run on.

src/content/blog/where-openclaw-security-is-heading.md

@@ -15,13 +15,30 @@ const { post } = Astro.props;
 const { Content } = await render(post);
 
 // Normalize authors - support both legacy single author and new multi-author format
-type Author = { name: string; handle: string };
+type Author = { name: string; handle?: string; url?: string; avatar?: string };
 const authors: Author[] = post.data.authors
   ? post.data.authors
-  : post.data.author && post.data.authorHandle
-    ? [{ name: post.data.author, handle: post.data.authorHandle }]
+  : post.data.author
+    ? [{
+        name: post.data.author,
+        handle: post.data.authorHandle,
+        url: post.data.authorUrl,
+        avatar: post.data.authorAvatar,
+      }]
     : [];
 
+function getAuthorAvatar(author: Author): string {
+  return author.avatar ?? (author.handle ? `https://unavatar.io/x/${author.handle}` : '/openclaw-logo-text-dark.png');
+}
+
+function getAuthorUrl(author: Author): string | null {
+  return author.url ?? (author.handle ? `https://x.com/${author.handle}` : null);
+}
+
+function getAuthorLabel(author: Author): string | null {
+  return author.handle ? `@${author.handle}` : author.url ? new URL(author.url).hostname.replace(/^www\./, '') : null;
+}
+
 function formatDate(date: Date): string {
   return date.toLocaleDateString('en-US', {
     year: 'numeric',
@@ -61,14 +78,16 @@ const postUrl = `https://openclaw.ai/blog/${post.id}`;
             {authors.map((author) => (
               <div class="author-info">
                 <img
-                  src={`https://unavatar.io/x/${author.handle}`}
+                  src={getAuthorAvatar(author)}
                   alt={author.name}
                   class="author-avatar"
                   loading="lazy"
                 />
                 <div class="author-details">
                   <span class="author-name">{author.name}</span>
-                  <a href={`https://x.com/${author.handle}`} class="author-handle" target="_blank" rel="noopener">@{author.handle}</a>
+                  {getAuthorUrl(author) && getAuthorLabel(author) && (
+                    <a href={getAuthorUrl(author)} class="author-handle" target="_blank" rel="noopener">{getAuthorLabel(author)}</a>
+                  )}
                 </div>
               </div>
             ))}

src/pages/blog/[...slug].astro

@@ -19,6 +19,21 @@ function estimateReadTime(content: string): string {
   const minutes = Math.ceil(words / wordsPerMinute);
   return `${minutes} min read`;
 }
+
+type Author = { name: string; handle?: string; url?: string; avatar?: string };
+
+function firstAuthor(post: (typeof posts)[number]): Author {
+  return post.data.authors?.[0] ?? {
+    name: post.data.author ?? 'OpenClaw Team',
+    handle: post.data.authorHandle,
+    url: post.data.authorUrl,
+    avatar: post.data.authorAvatar,
+  };
+}
+
+function getAuthorAvatar(author: Author): string {
+  return author.avatar ?? (author.handle ? `https://unavatar.io/x/${author.handle}` : '/openclaw-logo-text-dark.png');
+}
 ---
 
 <Layout title="Blog — OpenClaw">
@@ -46,13 +61,20 @@ function estimateReadTime(content: string): string {
           <p class="post-description">{post.data.description}</p>
           <div class="post-footer">
             <div class="post-author">
+              {(() => {
+                const author = firstAuthor(post);
+                return (
+                  <>
               <img
-                src={`https://unavatar.io/x/${post.data.authorHandle}`}
-                alt={post.data.author}
+                src={getAuthorAvatar(author)}
+                alt={author.name}
                 class="author-avatar"
                 loading="lazy"
               />
-              <span class="author-name">{post.data.author}</span>
+              <span class="author-name">{author.name}</span>
+                  </>
+                );
+              })()}
             </div>
             <div class="post-tags">
               {post.data.tags.map((tag) => (