How to Build a Secure Local-First Agent Runtime with OpenClaw Gateway, Skills, and Controlled Tool Execution

import os, json, textwrap, subprocess, time, re, pathlib, shlex
from getpass import getpass


def sh(cmd, test=True, seize=False, env=None):
   p = subprocess.run(
       ["bash", "-lc", cmd],
       test=test,
       textual content=True,
       capture_output=seize,
       env=env or os.environ.copy(),
   )
   return p.stdout if seize else None


def require_secret_env(var="OPENAI_API_KEY"):
   if os.environ.get(var, "").strip():
       return
   key = getpass(f"Enter {var} (hidden): ").strip()
   if not key:
       elevate RuntimeError(f"{var} is required.")
   os.environ[var] = key


def install_node_22_and_openclaw():
   sh("sudo apt-get replace -y")
   sh("sudo apt-get set up -y ca-certificates curl gnupg")
   sh("curl -fsSL https://deb.nodesource.com/setup_22.x | sudo -E bash -")
   sh("sudo apt-get set up -y nodejs")
   sh("node -v && npm -v")
   sh("npm set up -g openclaw@newest")
   sh("openclaw --version", test=False)

def write_openclaw_config_valid():
   residence = pathlib.Path.residence()
   base = residence / ".openclaw"
   workspace = base / "workspace"
   (workspace / "expertise").mkdir(mother and father=True, exist_ok=True)


   cfg = {
       "gateway": {
           "mode": "native",
           "port": 18789,
           "bind": "loopback",
           "auth": {"mode": "none"},
           "controlUi": {
               "enabled": True,
               "basePath": "/openclaw",
               "dangerouslyDisableDeviceAuth": True
           }
       },
       "brokers": {
           "defaults": {
               "workspace": str(workspace),
               "mannequin": {"main": "openai/gpt-4o-mini"}
           }
       },
       "instruments": {
           "exec": {
               "backgroundMs": 10000,
               "timeoutSec": 1800,
               "cleanupMs": 1800000,
               "notifyOnExit": True,
               "notifyOnExitEmptySuccess": False,
               "applyPatch": {"enabled": False, "allowModels": ["openai/gpt-5.2"]}
           }
       }
   }


   base.mkdir(mother and father=True, exist_ok=True)
   (base / "openclaw.json").write_text(json.dumps(cfg, indent=2))
   return str(base / "openclaw.json")


def start_gateway_background():
   sh("rm -f /tmp/openclaw_gateway.log /tmp/openclaw_gateway.pid", test=False)
   sh("nohup openclaw gateway --port 18789 --bind loopback --verbose > /tmp/openclaw_gateway.log 2>&1 & echo $! > /tmp/openclaw_gateway.pid")


   for _ in vary(60):
       time.sleep(1)
       log = sh("tail -n 120 /tmp/openclaw_gateway.log || true", seize=True, test=False) or ""
       if re.search(r"(listening|prepared|ws|http).*18789|18789.*listening", log, re.IGNORECASE):
           return True


   print("Gateway log tail:n", sh("tail -n 220 /tmp/openclaw_gateway.log || true", seize=True, test=False))
   elevate RuntimeError("OpenClaw gateway didn't begin cleanly.")

def pick_model_from_openclaw():
   out = sh("openclaw fashions listing --json", seize=True, test=False) or ""
   refs = []
   attempt:
       information = json.masses(out)
       if isinstance(information, dict):
           for okay in ["models", "items", "list"]:
               if isinstance(information.get(okay), listing):
                   information = information[k]
                   break
       if isinstance(information, listing):
           for it in information:
               if isinstance(it, str) and "/" in it:
                   refs.append(it)
               elif isinstance(it, dict):
                   for key in ["ref", "id", "model", "name"]:
                       v = it.get(key)
                       if isinstance(v, str) and "/" in v:
                           refs.append(v)
                           break
   besides Exception:
       go


   refs = [r for r in refs if r.startswith("openai/")]
   most popular = ["openai/gpt-4o-mini", "openai/gpt-4.1-mini", "openai/gpt-4o", "openai/gpt-5.2-mini", "openai/gpt-5.2"]
   for p in most popular:
       if p in refs:
           return p
   return refs[0] if refs else "openai/gpt-4o-mini"


def set_default_model(model_ref):
   sh(f'openclaw config set brokers.defaults.mannequin.main "{model_ref}"', test=False)

def create_custom_skill_rag():
   residence = pathlib.Path.residence()
   skill_dir = residence / ".openclaw" / "workspace" / "expertise" / "colab_rag_lab"
   skill_dir.mkdir(mother and father=True, exist_ok=True)


   tool_py = skill_dir / "rag_tool.py"
   tool_py.write_text(textwrap.dedent(r"""
       import sys, re, subprocess
       def pip(*args): subprocess.check_call([sys.executable, "-m", "pip", "-q", "install", *args])


       q = " ".be a part of(sys.argv[1:]).strip()
       if not q:
           print("Usage: python3 rag_tool.py <query>", file=sys.stderr)
           elevate SystemExit(2)


       attempt:
           import numpy as np
       besides Exception:
           pip("numpy"); import numpy as np


       attempt:
           import faiss
       besides Exception:
           pip("faiss-cpu"); import faiss


       attempt:
           from sentence_transformers import SentenceTransformer
       besides Exception:
           pip("sentence-transformers"); from sentence_transformers import SentenceTransformer


       CORPUS = [
           ("OpenClaw basics", "OpenClaw runs an agent runtime behind a local gateway and can execute tools and skills in a controlled way."),
           ("Strict config schema", "OpenClaw gateway refuses to start if openclaw.json has unknown keys; use openclaw doctor to diagnose issues."),
           ("Exec tool config", "tools.exec config sets timeouts and behavior; it does not use an enabled flag in the config schema."),
           ("Gateway auth", "Even on localhost, gateway auth exists; auth.mode can be none for trusted loopback-only setups."),
           ("Skills", "Skills define repeatable tool-use patterns; agents can select a skill and then call exec with a fixed command template.")
       ]


       docs = []
       for title, physique in CORPUS:
           sents = re.cut up(r'(?<=[.!?])s+', physique.strip())
           for i, s in enumerate(sents):
               s = s.strip()
               if s:
                   docs.append((f"{title}#{i+1}", s))


       mannequin = SentenceTransformer("all-MiniLM-L6-v2")
       emb = mannequin.encode([d[1] for d in docs], normalize_embeddings=True).astype("float32")
       index = faiss.IndexFlatIP(emb.form[1])
       index.add(emb)


       q_emb = mannequin.encode([q], normalize_embeddings=True).astype("float32")
       D, I = index.search(q_emb, 4)


       hits = []
       for rating, idx in zip(D[0].tolist(), I[0].tolist()):
           if idx >= 0:
               ref, txt = docs[idx]
               hits.append((rating, ref, txt))


       print("Answer (grounded to retrieved snippets):n")
       print("Question:", q, "n")
       print("Key factors:")
       for rating, ref, txt in hits:
           print(f"- ({rating:.3f}) {txt} [{ref}]")
       print("nCitations:")
       for _, ref, _ in hits:
           print(f"- {ref}")
   """).strip() + "n")
   sh(f"chmod +x {shlex.quote(str(tool_py))}")


   skill_md = skill_dir / "SKILL.md"
   skill_md.write_text(textwrap.dedent(f"""
       ---
       identify: colab_rag_lab
       description: Deterministic native RAG invoked by way of a fastened exec command.
       ---


       # Colab RAG Lab


       ## Tooling rule (strict)
       Always run precisely:
       `python3 {tool_py} "<QUESTION>"`


       ## Output rule
       Return the instrument output verbatim.
   """).strip() + "n")

def refresh_skills():
   sh('openclaw agent --message "refresh expertise" --thinking low', test=False)


def run_openclaw_agent_demo():
   immediate = (
       'Use the talent `colab_rag_lab` to reply: '
       'Why did my gateway refuse to begin once I used brokers.defaults.considering and instruments.exec.enabled, '
       'and what are the proper config knobs as an alternative?'
   )
   out = sh(f'openclaw agent --message {shlex.quote(immediate)} --thinking excessive', seize=True, test=False)
   print(out)


require_secret_env("OPENAI_API_KEY")
install_node_22_and_openclaw()


cfg_path = write_openclaw_config_valid()
print("Wrote schema-valid config:", cfg_path)


print("n--- openclaw physician ---n")
print(sh("openclaw physician", seize=True, test=False))


start_gateway_background()


mannequin = pick_model_from_openclaw()
set_default_model(mannequin)
print("Selected mannequin:", mannequin)


create_custom_skill_rag()
refresh_skills()


print("n--- OpenClaw agent run (skill-driven) ---n")
run_openclaw_agent_demo()


print("n--- Gateway log tail ---n")
print(sh("tail -n 180 /tmp/openclaw_gateway.log || true", seize=True, test=False))