@silicaclaw/cli 2026.3.20-2 → 2026.3.20-4

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

@@ -12,6 +12,7 @@ const OWNER_FORWARD_CMD = String(process.env.OPENCLAW_OWNER_FORWARD_CMD || "").t
 const STATE_PATH = resolve(
   String(process.env.OPENCLAW_OWNER_FORWARD_STATE_PATH || resolve(homedir(), ".openclaw", "workspace", "state", "silicaclaw-owner-push.json"))
 );
+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");
 
@@ -61,14 +62,24 @@ function loadState() {
     return {
       seen_ids: [],
       pushed_at: {},
+      last_pushed_created_at: 0,
+      last_pushed_message_id: "",
     };
   }
   try {
-    return JSON.parse(readFileSync(STATE_PATH, "utf8"));
+    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: "",
     };
   }
 }
@@ -85,6 +96,22 @@ function trimState(state) {
   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());
@@ -165,29 +192,60 @@ function dispatchToOwner(route, summary, message) {
 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 (state.seen_ids.includes(messageId)) continue;
-
-    state.seen_ids.push(messageId);
+    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;
     }
 
-    const summary = summarizeForOwner(item);
-    await dispatchToOwner(route, summary, item);
-    state.pushed_at[messageId] = new Date().toISOString();
-    if (VERBOSE) console.log(`pushed to owner: ${messageId}`);
+    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);
@@ -199,6 +257,7 @@ async function main() {
   if (VERBOSE) {
     console.log(`SilicaClaw owner push watching ${API_BASE}`);
     console.log(`State file: ${STATE_PATH}`);
+    console.log(`Latest-only mode: ${LATEST_ONLY ? "on" : "off"}`);
   }
 
   do {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@silicaclaw/cli",
-  "version": "2026.3.20-2",
+  "version": "2026.3.20-4",
   "private": false,
   "publishConfig": {
     "access": "public"

package/packages/network/dist/packages/network/src/relayPreview.d.ts

@@ -162,5 +162,6 @@ export declare class RelayPreviewAdapter implements NetworkAdapter {
     private requestJson;
     private updatePeersFromList;
     private scheduleNextPoll;
+    private ensurePollingAlive;
 }
 export {};

package/packages/network/dist/packages/network/src/relayPreview.js

@@ -349,6 +349,7 @@ class RelayPreviewAdapter {
         if (!this.lastJoinAt || Date.now() - this.lastJoinAt > Math.max(45_000, this.pollIntervalMs * 6)) {
             await this.joinRoom(reason);
         }
+        this.ensurePollingAlive(reason);
     }
     async get(path) {
         return this.requestJson("GET", path);
@@ -444,5 +445,21 @@ class RelayPreviewAdapter {
             this.pollOnce().catch(() => { });
         }, Math.max(1000, delayMs + jitterMs));
     }
+    ensurePollingAlive(reason) {
+        if (!this.started)
+            return;
+        const pollStaleMs = Math.max(45_000, this.pollIntervalMs * 6);
+        const pollMissing = !this.poller;
+        const pollStale = Boolean(this.lastPollAt) && Date.now() - this.lastPollAt > pollStaleMs;
+        if (!pollMissing && !pollStale) {
+            return;
+        }
+        this.recordDiscovery("poll_recover_scheduled", {
+            endpoint: this.activeEndpoint,
+            detail: `${reason}:${pollMissing ? "missing" : "stale"}`,
+        });
+        this.currentPollDelayMs = this.pollIntervalMs;
+        this.scheduleNextPoll(0);
+    }
 }
 exports.RelayPreviewAdapter = RelayPreviewAdapter;

package/packages/network/src/relayPreview.ts

@@ -467,6 +467,7 @@ export class RelayPreviewAdapter implements NetworkAdapter {
     if (!this.lastJoinAt || Date.now() - this.lastJoinAt > Math.max(45_000, this.pollIntervalMs * 6)) {
       await this.joinRoom(reason);
     }
+    this.ensurePollingAlive(reason);
   }
 
   private async get(path: string): Promise<any> {
@@ -565,4 +566,20 @@ export class RelayPreviewAdapter implements NetworkAdapter {
       this.pollOnce().catch(() => {});
     }, Math.max(1000, delayMs + jitterMs));
   }
+
+  private ensurePollingAlive(reason: string): void {
+    if (!this.started) return;
+    const pollStaleMs = Math.max(45_000, this.pollIntervalMs * 6);
+    const pollMissing = !this.poller;
+    const pollStale = Boolean(this.lastPollAt) && Date.now() - this.lastPollAt > pollStaleMs;
+    if (!pollMissing && !pollStale) {
+      return;
+    }
+    this.recordDiscovery("poll_recover_scheduled", {
+      endpoint: this.activeEndpoint,
+      detail: `${reason}:${pollMissing ? "missing" : "stale"}`,
+    });
+    this.currentPollDelayMs = this.pollIntervalMs;
+    this.scheduleNextPoll(0);
+  }
 }

package/scripts/silicaclaw-cli.mjs

@@ -224,10 +224,12 @@ function shellInitTargets() {
     shell.endsWith("/bash") ||
     process.env.BASH_VERSION ||
     existsSync(resolve(home, ".bashrc")) ||
-    existsSync(resolve(home, ".bash_profile"))
+    existsSync(resolve(home, ".bash_profile")) ||
+    existsSync(resolve(home, ".profile"))
   ) {
     add(resolve(home, ".bashrc"));
     add(resolve(home, ".bash_profile"));
+    add(resolve(home, ".profile"));
   }
 
   if (targets.length === 0) {
@@ -280,6 +282,7 @@ function installPersistentCommand(specifier = readPackageVersion()) {
   kv("Command", "silicaclaw");
   console.log("");
   kv("Activate", `source "${envFile}"`);
+  kv("Current shell", "run Activate now if `silicaclaw` is not found yet");
   if (configuredFiles.length > 0) {
     kv("Startup", "configured");
   } else {

package/scripts/silicaclaw-gateway.mjs

@@ -74,6 +74,11 @@ function readJson(file) {
   }
 }
 
+function readPackageVersionFrom(dir) {
+  const pkg = readJson(resolve(dir, "package.json"));
+  return String(pkg?.version || "latest").trim() || "latest";
+}
+
 function isSilicaClawDir(dir) {
   const pkgPath = join(dir, "package.json");
   if (!existsSync(pkgPath)) return false;
@@ -144,6 +149,107 @@ function ensureStateDir() {
   mkdirSync(STATE_DIR, { recursive: true });
 }
 
+function userShimDir() {
+  return join(homedir(), ".silicaclaw", "bin");
+}
+
+function userShimPath() {
+  return join(userShimDir(), "silicaclaw");
+}
+
+function userEnvFile() {
+  return join(homedir(), ".silicaclaw", "env.sh");
+}
+
+function userNpmCacheDir() {
+  return join(homedir(), ".silicaclaw", "npm-cache");
+}
+
+function preferredShellRcFile() {
+  const shell = String(process.env.SHELL || "");
+  if (shell.endsWith("/zsh")) return resolve(homedir(), ".zshrc");
+  if (shell.endsWith("/bash")) return resolve(homedir(), ".bashrc");
+  if (process.env.ZSH_VERSION) return resolve(homedir(), ".zshrc");
+  return resolve(homedir(), ".bashrc");
+}
+
+function shellInitTargets() {
+  const home = homedir();
+  const shell = String(process.env.SHELL || "");
+  const targets = [];
+  const add = (filePath) => {
+    if (!targets.includes(filePath)) targets.push(filePath);
+  };
+
+  if (shell.endsWith("/zsh") || process.env.ZSH_VERSION || existsSync(resolve(home, ".zshrc"))) {
+    add(resolve(home, ".zshrc"));
+  }
+
+  if (
+    shell.endsWith("/bash") ||
+    process.env.BASH_VERSION ||
+    existsSync(resolve(home, ".bashrc")) ||
+    existsSync(resolve(home, ".bash_profile")) ||
+    existsSync(resolve(home, ".profile"))
+  ) {
+    add(resolve(home, ".bashrc"));
+    add(resolve(home, ".bash_profile"));
+    add(resolve(home, ".profile"));
+  }
+
+  if (targets.length === 0) {
+    add(preferredShellRcFile());
+  }
+  return targets;
+}
+
+function ensureLineInFile(filePath, block) {
+  try {
+    const current = existsSync(filePath) ? readFileSync(filePath, "utf8") : "";
+    if (current.includes(block.trim())) return true;
+    const next = `${current.replace(/\s*$/, "")}\n\n${block}\n`;
+    mkdirSync(dirname(filePath), { recursive: true });
+    writeFileSync(filePath, next, "utf8");
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function shimScriptText(specifier = "latest") {
+  return [
+    "#!/usr/bin/env bash",
+    "set -euo pipefail",
+    'export npm_config_cache="${npm_config_cache:-$HOME/.silicaclaw/npm-cache}"',
+    `exec npx -y @silicaclaw/cli@${specifier} "$@"`,
+    "",
+  ].join("\n");
+}
+
+function ensureUserCommandInstalled() {
+  const version = readPackageVersionFrom(APP_DIR);
+  const envBlock = [
+    "#!/usr/bin/env bash",
+    'export PATH="$HOME/.silicaclaw/bin:$PATH"',
+    'export npm_config_cache="$HOME/.silicaclaw/npm-cache"',
+    "",
+  ].join("\n");
+  const rcBlock = [
+    "# >>> silicaclaw >>>",
+    '[ -f "$HOME/.silicaclaw/env.sh" ] && . "$HOME/.silicaclaw/env.sh"',
+    "# <<< silicaclaw <<<",
+  ].join("\n");
+
+  mkdirSync(userShimDir(), { recursive: true });
+  mkdirSync(userNpmCacheDir(), { recursive: true });
+  writeFileSync(userEnvFile(), envBlock, { encoding: "utf8", mode: 0o755 });
+  writeFileSync(userShimPath(), shimScriptText(version), { encoding: "utf8", mode: 0o755 });
+
+  for (const filePath of shellInitTargets()) {
+    ensureLineInFile(filePath, rcBlock);
+  }
+}
+
 function ensureLaunchAgentsDir() {
   mkdirSync(LAUNCH_AGENTS_DIR, { recursive: true });
 }
@@ -797,6 +903,7 @@ async function stopAll() {
 
 async function startAll() {
   ensureStateDir();
+  ensureUserCommandInstalled();
 
   const mode = parseMode(parseFlag("mode", process.env.NETWORK_MODE || DEFAULT_NETWORK_MODE));
   const adapter = adapterForMode(mode);
@@ -923,6 +1030,7 @@ async function startAll() {
 }
 
 async function restartAll() {
+  ensureUserCommandInstalled();
   if (!isLaunchdPlatform()) {
     await stopAll();
     await startAll();

package/scripts/validate-openclaw-skill.mjs

@@ -100,6 +100,25 @@ function main() {
         assert(dialogueCheatsheetZh.includes("主人对话速查表"), "owner dialogue cheatsheet zh content mismatch");
       },
     },
+    "silicaclaw-network-config": {
+      requiredFiles: [
+        resolve(skillDir, "references", "network-modes.md"),
+        resolve(skillDir, "references", "public-discovery.md"),
+        resolve(skillDir, "references", "owner-dialogue-cheatsheet-zh.md"),
+      ],
+      uiDisplayName: 'display_name: "SilicaClaw Network Config"',
+      checks(manifest, files) {
+        const networkModes = readFileSync(files[0], "utf8");
+        const publicDiscovery = readFileSync(files[1], "utf8");
+        const dialogueCheatsheetZh = readFileSync(files[2], "utf8");
+        assert(String(manifest.references?.network_modes || "") === "references/network-modes.md", "manifest network modes reference mismatch");
+        assert(String(manifest.references?.public_discovery || "") === "references/public-discovery.md", "manifest public discovery reference mismatch");
+        assert(String(manifest.references?.owner_dialogue_cheatsheet_zh || "") === "references/owner-dialogue-cheatsheet-zh.md", "manifest owner dialogue cheatsheet zh reference mismatch");
+        assert(networkModes.includes("## Modes"), "network modes content mismatch");
+        assert(publicDiscovery.includes("public_enabled"), "public discovery content mismatch");
+        assert(dialogueCheatsheetZh.includes("主人对话速查表"), "owner dialogue cheatsheet zh content mismatch");
+      },
+    },
   }[skillName];
 
   assert(profile, `Unsupported skill for validation: ${skillName}`);