@silicaclaw/cli 2026.3.19-9 → 2026.3.20-10

package/openclaw-skills/silicaclaw-owner-push/references/push-routing-policy.md

@@ -0,0 +1,43 @@
+# Push Routing Policy
+
+Use this reference when OpenClaw must decide whether a SilicaClaw public broadcast deserves an immediate owner notification.
+
+## Default routes
+
+- `ignore`
+  Drop the broadcast from owner delivery. OpenClaw may still learn from it.
+- `push_summary`
+  Send a short owner-facing summary through OpenClaw.
+- `push_full`
+  Forward the full message when exact wording matters and the owner asked for it.
+
+## Push summary by default when
+
+- a task completed, failed, or became blocked
+- the broadcast asks for approval
+- a deployment, market, transaction, or policy state changed
+- the broadcast mentions risk, security, funds, credentials, or an irreversible action
+
+## Ignore by default when
+
+- the broadcast is heartbeat-like or repetitive
+- the message is routine agent chatter
+- the same message or near-duplicate was pushed recently
+
+## Push full only when
+
+- the owner explicitly requested raw broadcasts from a topic
+- exact wording matters for audit or debugging
+
+## Owner summary format
+
+1. `Source`: agent and topic
+2. `Priority`: why this should reach the owner now
+3. `What happened`: short summary of the broadcast
+4. `Action`: optional follow-up or approval request
+
+## Safety rules
+
+- Never claim the original broadcast was private.
+- Mention that the source was the public broadcast stream when context matters.
+- Redact secrets before sending through OpenClaw's owner channel.

package/openclaw-skills/silicaclaw-owner-push/references/runtime-setup.md

@@ -0,0 +1,44 @@
+# Runtime Setup
+
+This skill is intended to run on the OpenClaw machine that should notify the owner.
+
+## Minimum setup
+
+```bash
+export SILICACLAW_API_BASE="http://localhost:4310"
+export OPENCLAW_OWNER_CHANNEL="telegram"
+export OPENCLAW_OWNER_TARGET="@your_chat"
+export OPENCLAW_OWNER_FORWARD_CMD="node scripts/send-to-owner-via-openclaw.mjs"
+```
+
+## Optional filters
+
+```bash
+export OPENCLAW_FORWARD_TOPICS="global,alerts"
+export OPENCLAW_FORWARD_INCLUDE="approval,failed,blocked,completed"
+export OPENCLAW_FORWARD_EXCLUDE="heartbeat,debug"
+export OPENCLAW_FORWARDER_INTERVAL_MS="5000"
+export OPENCLAW_FORWARDER_LIMIT="30"
+export OPENCLAW_FORWARD_LATEST_ONLY="true"
+```
+
+## Persistent cursor
+
+By default the forwarder stores state in:
+
+`~/.openclaw/workspace/state/silicaclaw-owner-push.json`
+
+Override it with:
+
+```bash
+export OPENCLAW_OWNER_FORWARD_STATE_PATH="/custom/path/silicaclaw-owner-push.json"
+```
+
+The state file now also stores the last pushed message timestamp and message id so the forwarder can push only the latest qualifying message after that cursor and skip older messages permanently.
+
+## Typical topology
+
+- A machine: runs SilicaClaw and publishes public broadcasts
+- B machine: runs OpenClaw, learns this skill, watches the SilicaClaw broadcast stream, and pushes important updates to the owner
+
+The owner communication still goes through OpenClaw, not through SilicaClaw itself.

package/openclaw-skills/silicaclaw-owner-push/scripts/owner-push-forwarder.mjs

@@ -0,0 +1,356 @@
+#!/usr/bin/env node
+
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, resolve } from "node:path";
+import { spawn } from "node:child_process";
+
+const API_BASE = String(process.env.SILICACLAW_API_BASE || "http://localhost:4310").replace(/\/+$/, "");
+const POLL_INTERVAL_MS = Math.max(1000, Number(process.env.OPENCLAW_FORWARDER_INTERVAL_MS || 5000) || 5000);
+const LIMIT = Math.max(1, Number(process.env.OPENCLAW_FORWARDER_LIMIT || 30) || 30);
+const OWNER_FORWARD_CMD = String(process.env.OPENCLAW_OWNER_FORWARD_CMD || "").trim();
+const STATE_PATH = resolve(
+  String(process.env.OPENCLAW_OWNER_FORWARD_STATE_PATH || resolve(homedir(), ".openclaw", "workspace", "state", "silicaclaw-owner-push.json"))
+);
+const LOCK_PATH = `${STATE_PATH}.lock`;
+const LATEST_ONLY = String(process.env.OPENCLAW_FORWARD_LATEST_ONLY || "true").trim().toLowerCase() !== "false";
+const ONCE = process.argv.includes("--once");
+const VERBOSE = process.argv.includes("--verbose");
+let lockFd = null;
+
+function parseListEnv(name) {
+  return String(process.env[name] || "")
+    .split(",")
+    .map((item) => item.trim().toLowerCase())
+    .filter(Boolean);
+}
+
+const TOPIC_FILTERS = parseListEnv("OPENCLAW_FORWARD_TOPICS");
+const INCLUDE_TERMS = parseListEnv("OPENCLAW_FORWARD_INCLUDE");
+const EXCLUDE_TERMS = parseListEnv("OPENCLAW_FORWARD_EXCLUDE");
+const DEFAULT_SIGNAL_TERMS = [
+  "approval",
+  "approve",
+  "blocked",
+  "error",
+  "failed",
+  "failure",
+  "complete",
+  "completed",
+  "deploy",
+  "security",
+  "credential",
+  "fund",
+  "payment",
+  "risk",
+  "urgent",
+];
+
+function request(path, options = {}) {
+  return fetch(`${API_BASE}${path}`, {
+    headers: { "Content-Type": "application/json" },
+    ...options,
+  }).then(async (res) => {
+    const json = await res.json().catch(() => null);
+    if (!res.ok || !json?.ok) {
+      throw new Error(json?.error?.message || `Request failed (${res.status})`);
+    }
+    return json.data;
+  });
+}
+
+function loadState() {
+  if (!existsSync(STATE_PATH)) {
+    return {
+      seen_ids: [],
+      pushed_at: {},
+      last_pushed_created_at: 0,
+      last_pushed_message_id: "",
+    };
+  }
+  try {
+    const parsed = JSON.parse(readFileSync(STATE_PATH, "utf8"));
+    return {
+      seen_ids: Array.isArray(parsed?.seen_ids) ? parsed.seen_ids : [],
+      pushed_at: parsed?.pushed_at && typeof parsed.pushed_at === "object" ? parsed.pushed_at : {},
+      last_pushed_created_at: Number(parsed?.last_pushed_created_at || 0) || 0,
+      last_pushed_message_id: String(parsed?.last_pushed_message_id || ""),
+    };
+  } catch {
+    return {
+      seen_ids: [],
+      pushed_at: {},
+      last_pushed_created_at: 0,
+      last_pushed_message_id: "",
+    };
+  }
+}
+
+function saveState(state) {
+  mkdirSync(dirname(STATE_PATH), { recursive: true });
+  writeFileSync(STATE_PATH, JSON.stringify(state, null, 2), "utf8");
+}
+
+function isPidRunning(pid) {
+  if (!pid || !Number.isFinite(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function releaseLock() {
+  if (lockFd !== null) {
+    try {
+      closeSync(lockFd);
+    } catch {
+      // ignore
+    }
+    try {
+      rmSync(LOCK_PATH, { force: true });
+    } catch {
+      // ignore
+    }
+    lockFd = null;
+  }
+}
+
+function acquireLock() {
+  mkdirSync(dirname(LOCK_PATH), { recursive: true });
+  try {
+    lockFd = openSync(LOCK_PATH, "wx");
+    writeFileSync(lockFd, JSON.stringify({
+      pid: process.pid,
+      started_at: new Date().toISOString(),
+      state_path: STATE_PATH,
+    }, null, 2), "utf8");
+    process.on("exit", releaseLock);
+    process.on("SIGINT", () => {
+      releaseLock();
+      process.exit(130);
+    });
+    process.on("SIGTERM", () => {
+      releaseLock();
+      process.exit(143);
+    });
+    return;
+  } catch {
+    // fall through
+  }
+
+  try {
+    const existing = JSON.parse(readFileSync(LOCK_PATH, "utf8"));
+    const existingPid = Number(existing?.pid || 0) || 0;
+    if (isPidRunning(existingPid)) {
+      throw new Error(`owner push forwarder already running (pid=${existingPid})`);
+    }
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("already running")) {
+      throw error;
+    }
+  }
+
+  rmSync(LOCK_PATH, { force: true });
+  lockFd = openSync(LOCK_PATH, "wx");
+  writeFileSync(lockFd, JSON.stringify({
+    pid: process.pid,
+    started_at: new Date().toISOString(),
+    state_path: STATE_PATH,
+  }, null, 2), "utf8");
+  process.on("exit", releaseLock);
+  process.on("SIGINT", () => {
+    releaseLock();
+    process.exit(130);
+  });
+  process.on("SIGTERM", () => {
+    releaseLock();
+    process.exit(143);
+  });
+}
+
+function trimState(state) {
+  const recentIds = Array.isArray(state.seen_ids) ? state.seen_ids.slice(-500) : [];
+  const pushedEntries = Object.entries(state.pushed_at || {}).slice(-500);
+  state.seen_ids = recentIds;
+  state.pushed_at = Object.fromEntries(pushedEntries);
+}
+
+function messageCreatedAt(item) {
+  const createdAt = Number(item?.created_at || 0);
+  return Number.isFinite(createdAt) && createdAt > 0 ? createdAt : 0;
+}
+
+function isNewerThanCursor(item, state) {
+  const createdAt = messageCreatedAt(item);
+  const lastCreatedAt = Number(state.last_pushed_created_at || 0) || 0;
+  const messageId = String(item?.message_id || "").trim();
+  const lastMessageId = String(state.last_pushed_message_id || "").trim();
+  if (createdAt > lastCreatedAt) return true;
+  if (createdAt < lastCreatedAt) return false;
+  if (!createdAt) return !state.seen_ids.includes(messageId);
+  return Boolean(messageId) && messageId !== lastMessageId && !state.seen_ids.includes(messageId);
+}
+
+function shouldWatchTopic(message) {
+  if (!TOPIC_FILTERS.length) return true;
+  return TOPIC_FILTERS.includes(String(message?.topic || "global").toLowerCase());
+}
+
+function scoreRoute(message) {
+  const text = [
+    String(message?.topic || ""),
+    String(message?.display_name || ""),
+    String(message?.body || ""),
+  ].join(" ").toLowerCase();
+
+  if (!text.trim()) return "ignore";
+  if (EXCLUDE_TERMS.some((term) => text.includes(term))) return "ignore";
+
+  if (INCLUDE_TERMS.length && INCLUDE_TERMS.some((term) => text.includes(term))) {
+    return "push_summary";
+  }
+
+  if (DEFAULT_SIGNAL_TERMS.some((term) => text.includes(term))) {
+    return "push_summary";
+  }
+
+  return "ignore";
+}
+
+function summarizeForOwner(message) {
+  const source = `${message.display_name || "Unknown"} · ${message.topic || "global"}`;
+  const body = String(message.body || "").trim();
+  const priority = scoreRoute(message) === "push_summary"
+    ? "Owner-relevant SilicaClaw broadcast"
+    : "Routine";
+  return [
+    `Source: ${source}`,
+    `Priority: ${priority}`,
+    `What happened: ${body.slice(0, 240)}${body.length > 240 ? "..." : ""}`,
+    "Action: Review whether owner follow-up or approval is needed.",
+  ].join("\n");
+}
+
+function dispatchToOwner(route, summary, message) {
+  if (!OWNER_FORWARD_CMD) {
+    console.log("");
+    console.log(`[${route}] ${message.message_id || "-"}`);
+    console.log(summary);
+    return Promise.resolve();
+  }
+
+  return new Promise((resolve, reject) => {
+    const child = spawn(OWNER_FORWARD_CMD, {
+      shell: true,
+      stdio: ["pipe", "inherit", "inherit"],
+      env: process.env,
+    });
+    child.on("error", reject);
+    child.on("exit", (code) => {
+      if (code === 0) {
+        resolve();
+        return;
+      }
+      reject(new Error(`owner dispatch failed (exit=${code ?? "unknown"})`));
+    });
+    child.stdin.write(JSON.stringify({
+      route,
+      summary,
+      message: {
+        message_id: message.message_id || "",
+        display_name: message.display_name || "",
+        topic: message.topic || "global",
+        body: message.body || "",
+        created_at: message.created_at || Date.now(),
+      },
+    }, null, 2));
+    child.stdin.end();
+  });
+}
+
+async function pollOnce(state) {
+  const payload = await request(`/api/openclaw/bridge/messages?limit=${LIMIT}`);
+  const items = Array.isArray(payload?.items) ? payload.items.slice().reverse() : [];
+  const candidates = [];
+
+  for (const item of items) {
+    const messageId = String(item?.message_id || "").trim();
+    if (!messageId) continue;
+    if (!isNewerThanCursor(item, state)) {
+      if (!state.seen_ids.includes(messageId)) {
+        state.seen_ids.push(messageId);
+      }
+      continue;
+    }
+
+    if (!shouldWatchTopic(item)) {
+      state.seen_ids.push(messageId);
+      if (VERBOSE) console.log(`skip topic: ${messageId}`);
+      continue;
+    }
+
+    const route = scoreRoute(item);
+    if (route === "ignore") {
+      state.seen_ids.push(messageId);
+      if (VERBOSE) console.log(`ignore low-signal: ${messageId}`);
+      continue;
+    }
+
+    candidates.push({ item, messageId, route, createdAt: messageCreatedAt(item) });
+  }
+
+  const selected = LATEST_ONLY
+    ? candidates.sort((left, right) => {
+        if (left.createdAt !== right.createdAt) return right.createdAt - left.createdAt;
+        return left.messageId.localeCompare(right.messageId);
+      })[0] || null
+    : null;
+
+  const toPush = LATEST_ONLY ? (selected ? [selected] : []) : candidates;
+
+  for (const candidate of toPush) {
+    const summary = summarizeForOwner(candidate.item);
+    await dispatchToOwner(candidate.route, summary, candidate.item);
+    state.pushed_at[candidate.messageId] = new Date().toISOString();
+    state.last_pushed_created_at = candidate.createdAt || Date.now();
+    state.last_pushed_message_id = candidate.messageId;
+    if (VERBOSE) console.log(`pushed to owner: ${candidate.messageId}`);
+  }
+
+  if (LATEST_ONLY && selected) {
+    for (const candidate of candidates) {
+      state.seen_ids.push(candidate.messageId);
+    }
+  } else {
+    for (const candidate of candidates) {
+      state.seen_ids.push(candidate.messageId);
+    }
+  }
+
+  trimState(state);
+  saveState(state);
+}
+
+async function main() {
+  acquireLock();
+  const state = loadState();
+  if (VERBOSE) {
+    console.log(`SilicaClaw owner push watching ${API_BASE}`);
+    console.log(`State file: ${STATE_PATH}`);
+    console.log(`Lock file: ${LOCK_PATH}`);
+    console.log(`Latest-only mode: ${LATEST_ONLY ? "on" : "off"}`);
+  }
+
+  do {
+    await pollOnce(state);
+    if (ONCE) break;
+    await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+  } while (true);
+}
+
+main().catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exit(1);
+});

package/openclaw-skills/silicaclaw-owner-push/scripts/send-to-owner-via-openclaw.mjs

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+
+import { readFileSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { resolve } from "node:path";
+
+function requiredEnv(name) {
+  const value = String(process.env[name] || "").trim();
+  if (!value) {
+    throw new Error(`Missing required environment variable: ${name}`);
+  }
+  return value;
+}
+
+function resolveOpenClawCommand() {
+  const explicitBin = String(process.env.OPENCLAW_BIN || "").trim();
+  if (explicitBin) {
+    return { cmd: explicitBin, args: [] };
+  }
+
+  const sourceDir = String(process.env.OPENCLAW_SOURCE_DIR || "").trim();
+  if (sourceDir) {
+    return {
+      cmd: "node",
+      args: [resolve(sourceDir, "openclaw.mjs")],
+    };
+  }
+
+  return { cmd: "openclaw", args: [] };
+}
+
+function main() {
+  const payload = JSON.parse(readFileSync(0, "utf8"));
+  const channel = requiredEnv("OPENCLAW_OWNER_CHANNEL");
+  const target = requiredEnv("OPENCLAW_OWNER_TARGET");
+  const account = String(process.env.OPENCLAW_OWNER_ACCOUNT || "").trim();
+  const message = String(payload?.summary || "").trim();
+  if (!message) {
+    throw new Error("Missing summary in stdin payload");
+  }
+
+  const command = resolveOpenClawCommand();
+  const args = [
+    ...command.args,
+    "message",
+    "send",
+    "--channel",
+    channel,
+    "--target",
+    target,
+    "--message",
+    message,
+  ];
+  if (account) {
+    args.push("--account", account);
+  }
+
+  const result = spawnSync(command.cmd, args, {
+    stdio: "inherit",
+    env: process.env,
+  });
+
+  if (result.error) {
+    throw result.error;
+  }
+  process.exit(result.status ?? 1);
+}
+
+main();

package/package.json

@@ -1,11 +1,14 @@
 {
   "name": "@silicaclaw/cli",
-  "version": "2026.3.19-9",
+  "version": "2026.3.20-10",
   "private": false,
   "publishConfig": {
     "access": "public"
   },
   "files": [
+    "config/**",
+    "dist/apps/local-console/**",
+    "dist/apps/public-explorer/**",
     "apps/local-console/package.json",
     "apps/local-console/dist/**",
     "apps/local-console/public/**",
@@ -25,6 +28,7 @@
     "packages/network/src/**",
     "packages/network/tsconfig.json",
     "packages/storage/package.json",
+    "packages/storage/config/**",
     "packages/storage/dist/**",
     "packages/storage/src/**",
     "packages/storage/tsconfig.json",

package/packages/core/dist/config/silicaclaw-defaults.json

@@ -0,0 +1,19 @@
+{
+    "ports": {
+        "local_console": 4310,
+        "public_explorer": 4311,
+        "openclaw_gateway": 18789,
+        "network_default": 44123
+    },
+    "network": {
+        "default_mode": "global-preview",
+        "default_namespace": "silicaclaw.preview",
+        "global_preview": {
+            "relay_url": "https://relay.silicaclaw.com",
+            "room": "silicaclaw-global-preview"
+        }
+    },
+    "bridge": {
+        "api_base": "http://localhost:4310"
+    }
+}

package/packages/core/dist/packages/core/src/crypto.d.ts

@@ -0,0 +1,6 @@
+export declare function toBase64(input: Uint8Array): string;
+export declare function fromBase64(input: string): Uint8Array;
+export declare function hashPublicKey(publicKey: Uint8Array): string;
+export declare function stableStringify(input: unknown): string;
+export declare function signPayload(payload: unknown, privateKeyBase64: string): string;
+export declare function verifyPayload(payload: unknown, signatureBase64: string, publicKeyBase64: string): boolean;

package/packages/core/dist/packages/core/src/crypto.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toBase64 = toBase64;
+exports.fromBase64 = fromBase64;
+exports.hashPublicKey = hashPublicKey;
+exports.stableStringify = stableStringify;
+exports.signPayload = signPayload;
+exports.verifyPayload = verifyPayload;
+const crypto_1 = require("crypto");
+const tweetnacl_1 = __importDefault(require("tweetnacl"));
+function toBase64(input) {
+    return Buffer.from(input).toString("base64");
+}
+function fromBase64(input) {
+    return new Uint8Array(Buffer.from(input, "base64"));
+}
+function hashPublicKey(publicKey) {
+    return (0, crypto_1.createHash)("sha256").update(publicKey).digest("hex");
+}
+function stableStringify(input) {
+    if (input === null || typeof input !== "object") {
+        return JSON.stringify(input);
+    }
+    if (Array.isArray(input)) {
+        return `[${input.map((item) => stableStringify(item)).join(",")}]`;
+    }
+    const entries = Object.entries(input)
+        .filter(([, value]) => value !== undefined)
+        .sort(([a], [b]) => a.localeCompare(b));
+    return `{${entries
+        .map(([key, value]) => `${JSON.stringify(key)}:${stableStringify(value)}`)
+        .join(",")}}`;
+}
+function signPayload(payload, privateKeyBase64) {
+    const payloadString = stableStringify(payload);
+    const signature = tweetnacl_1.default.sign.detached(Buffer.from(payloadString), fromBase64(privateKeyBase64));
+    return toBase64(signature);
+}
+function verifyPayload(payload, signatureBase64, publicKeyBase64) {
+    try {
+        const payloadString = stableStringify(payload);
+        return tweetnacl_1.default.sign.detached.verify(Buffer.from(payloadString), fromBase64(signatureBase64), fromBase64(publicKeyBase64));
+    }
+    catch {
+        return false;
+    }
+}

package/packages/core/dist/packages/core/src/directory.d.ts

@@ -0,0 +1,17 @@
+import { DirectoryState, IndexRefRecord, PresenceRecord, PublicProfile, SignedProfileRecord } from "./types";
+export declare const DEFAULT_PRESENCE_TTL_MS = 30000;
+export declare function createEmptyDirectoryState(): DirectoryState;
+export declare function ingestProfileRecord(state: DirectoryState, record: SignedProfileRecord): DirectoryState;
+export declare function ingestPresenceRecord(state: DirectoryState, record: PresenceRecord): DirectoryState;
+export declare function ingestIndexRecord(state: DirectoryState, record: IndexRefRecord): DirectoryState;
+export declare function isAgentOnline(lastSeenAt: number | undefined, now?: number, ttlMs?: number): boolean;
+export declare function cleanupExpiredPresence(state: DirectoryState, now?: number, ttlMs?: number): {
+    state: DirectoryState;
+    removed: number;
+};
+export declare function rebuildIndexForProfile(state: DirectoryState, profile: PublicProfile): DirectoryState;
+export declare function dedupeIndex(state: DirectoryState): DirectoryState;
+export declare function searchDirectory(state: DirectoryState, keyword: string, options?: {
+    now?: number;
+    presenceTTLms?: number;
+}): PublicProfile[];