@silicaclaw/cli 2026.3.20-3 → 2026.3.20-4

package/apps/local-console/src/server.ts

@@ -1,6 +1,6 @@
 import express, { NextFunction, Request, Response } from "express";
 import cors from "cors";
-import { execFile, spawnSync } from "child_process";
+import { execFile, spawn, spawnSync } from "child_process";
 import { resolve } from "path";
 import { accessSync, constants, copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, statSync } from "fs";
 import { createHash } from "crypto";
@@ -90,6 +90,7 @@ const DEFAULT_BRIDGE_API_BASE = defaults.bridge.api_base;
 const OPENCLAW_GATEWAY_PORT = defaults.ports.openclaw_gateway;
 const OPENCLAW_GATEWAY_URL = `http://${OPENCLAW_GATEWAY_HOST}:${OPENCLAW_GATEWAY_PORT}/`;
 const NETWORK_PEER_REMOVE_AFTER_MS = Number(process.env.NETWORK_PEER_REMOVE_AFTER_MS || 180_000);
+const DIRECTORY_REMOTE_PROFILE_SOFT_LIMIT = Number(process.env.DIRECTORY_REMOTE_PROFILE_SOFT_LIMIT || 1000);
 const NETWORK_UDP_BIND_ADDRESS = process.env.NETWORK_UDP_BIND_ADDRESS || "0.0.0.0";
 const NETWORK_UDP_BROADCAST_ADDRESS = process.env.NETWORK_UDP_BROADCAST_ADDRESS || "255.255.255.255";
 const NETWORK_PEER_ID = process.env.NETWORK_PEER_ID;
@@ -157,6 +158,10 @@ function normalizeVersionText(value: unknown): string {
   return text.startsWith("v") ? text.slice(1) : text;
 }
 
+function formatBytesToMiB(value: number): number {
+  return Math.round((value / (1024 * 1024)) * 10) / 10;
+}
+
 function tokenizeVersion(value: unknown): Array<number | string> {
   return normalizeVersionText(value)
     .split(/[^0-9A-Za-z]+/)
@@ -186,6 +191,10 @@ function compareVersionTokens(left: unknown, right: unknown): number {
   return 0;
 }
 
+function userNpmCacheDir(): string {
+  return resolve(homedir(), ".silicaclaw", "npm-cache");
+}
+
 function resolveWorkspaceRoot(cwd = process.cwd()): string {
   if (existsSync(resolve(cwd, "apps", "local-console", "package.json"))) {
     return cwd;
@@ -1201,6 +1210,7 @@ export class LocalNodeService {
     const relayCapable = this.adapterMode === "webrtc-preview" || this.adapterMode === "relay-preview";
     const peers: Array<{ status?: string }> = diagnostics?.peers?.items ?? [];
     const online = peers.filter((peer: { status?: string }) => peer.status === "online").length;
+    const memory = process.memoryUsage();
 
     return {
       adapter: this.adapterMode,
@@ -1225,6 +1235,23 @@ export class LocalNodeService {
       adapter_stats: diagnostics?.stats ?? null,
       adapter_transport_stats: diagnostics?.transport_stats ?? null,
       adapter_discovery_stats: diagnostics?.discovery_stats ?? null,
+      runtime_diagnostics: {
+        memory_mib: {
+          rss: formatBytesToMiB(memory.rss),
+          heap_used: formatBytesToMiB(memory.heapUsed),
+          heap_total: formatBytesToMiB(memory.heapTotal),
+          external: formatBytesToMiB(memory.external),
+        },
+        directory: {
+          profile_count: Object.keys(this.directory.profiles).length,
+          presence_count: Object.keys(this.directory.presence).length,
+          index_key_count: Object.keys(this.directory.index).length,
+        },
+        social: {
+          message_count: this.socialMessages.length,
+          observation_count: this.socialMessageObservations.length,
+        },
+      },
       adapter_diagnostics_summary: relayCapable || diagnostics
         ? {
             started: this.networkStarted,
@@ -1341,6 +1368,88 @@ export class LocalNodeService {
     };
   }
 
+  getAppUpdateStatus() {
+    const currentVersion = normalizeVersionText(this.appVersion) || "unknown";
+    const fallback = {
+      current_version: currentVersion,
+      latest_version: currentVersion,
+      update_available: false,
+      channel: "latest",
+      platform: process.platform,
+      checked_at: Date.now(),
+      can_update: true,
+      check_error: null as string | null,
+    };
+    try {
+      const result = spawnSync("npm", ["view", "@silicaclaw/cli", "dist-tags", "--json"], {
+        cwd: this.projectRoot,
+        encoding: "utf8",
+        env: {
+          ...process.env,
+          SILICACLAW_WORKSPACE_DIR: this.projectRoot,
+          SILICACLAW_APP_DIR: this.workspaceRoot,
+          npm_config_cache: process.env.npm_config_cache || userNpmCacheDir(),
+        },
+      });
+      if ((result.status ?? 1) !== 0) {
+        return {
+          ...fallback,
+          check_error: String(result.stderr || result.stdout || "npm view failed").trim() || "npm view failed",
+        };
+      }
+      const tags = JSON.parse(String(result.stdout || "{}").trim() || "{}") as { latest?: string };
+      const latestVersion = normalizeVersionText(tags.latest || currentVersion) || currentVersion;
+      return {
+        ...fallback,
+        latest_version: latestVersion,
+        update_available: compareVersionTokens(latestVersion, currentVersion) > 0,
+      };
+    } catch (error) {
+      return {
+        ...fallback,
+        check_error: error instanceof Error ? error.message : String(error),
+      };
+    }
+  }
+
+  startAppUpdate(): { started: boolean; target_version: string; platform: string; reason?: string } {
+    const status = this.getAppUpdateStatus();
+    if (!status.update_available || !status.latest_version) {
+      return {
+        started: false,
+        target_version: status.latest_version || status.current_version,
+        platform: process.platform,
+        reason: status.check_error || "already_current",
+      };
+    }
+    const scriptPath = resolve(this.workspaceRoot, "scripts", "silicaclaw-cli.mjs");
+    if (!existsSync(scriptPath)) {
+      return {
+        started: false,
+        target_version: status.latest_version,
+        platform: process.platform,
+        reason: "missing_cli_script",
+      };
+    }
+    const child = spawn(process.execPath, [scriptPath, "update"], {
+      cwd: this.projectRoot,
+      detached: true,
+      stdio: "ignore",
+      env: {
+        ...process.env,
+        SILICACLAW_WORKSPACE_DIR: this.projectRoot,
+        SILICACLAW_APP_DIR: this.workspaceRoot,
+        npm_config_cache: process.env.npm_config_cache || userNpmCacheDir(),
+      },
+    });
+    child.unref();
+    return {
+      started: true,
+      target_version: status.latest_version,
+      platform: process.platform,
+    };
+  }
+
   getIntegrationSummary() {
     const status = this.getIntegrationStatus();
     const runtimeGenerated = Boolean(this.socialRuntime && this.socialRuntime.last_loaded_at > 0);
@@ -2670,9 +2779,66 @@ export class LocalNodeService {
     this.networkReconnectDelayMs = Math.min(30_000, Math.max(5_000, Math.floor(delayMs * 1.5)));
   }
 
+  private pruneRemoteProfilesInMemory(now = Date.now()): number {
+    if (!Number.isFinite(DIRECTORY_REMOTE_PROFILE_SOFT_LIMIT) || DIRECTORY_REMOTE_PROFILE_SOFT_LIMIT <= 0) {
+      return 0;
+    }
+    const selfAgentId = this.profile?.agent_id || this.identity?.agent_id || "";
+    const remoteProfiles = Object.values(this.directory.profiles).filter((profile) => profile.agent_id !== selfAgentId);
+    if (remoteProfiles.length <= DIRECTORY_REMOTE_PROFILE_SOFT_LIMIT) {
+      return 0;
+    }
+
+    const onlineRemoteProfiles = remoteProfiles.filter((profile) =>
+      isAgentOnline(this.directory.presence[profile.agent_id], now, PRESENCE_TTL_MS)
+    );
+    const offlineRemoteProfiles = remoteProfiles
+      .filter((profile) => !isAgentOnline(this.directory.presence[profile.agent_id], now, PRESENCE_TTL_MS))
+      .sort((a, b) => (b.updated_at || 0) - (a.updated_at || 0));
+
+    const keepOfflineCount = Math.max(0, DIRECTORY_REMOTE_PROFILE_SOFT_LIMIT - onlineRemoteProfiles.length);
+    const keptRemoteProfiles = [
+      ...onlineRemoteProfiles,
+      ...offlineRemoteProfiles.slice(0, keepOfflineCount),
+    ];
+    const keptRemoteIds = new Set(keptRemoteProfiles.map((profile) => profile.agent_id));
+    const removedIds = remoteProfiles
+      .map((profile) => profile.agent_id)
+      .filter((agentId) => !keptRemoteIds.has(agentId));
+    if (removedIds.length === 0) {
+      return 0;
+    }
+
+    const next = createEmptyDirectoryState();
+    const selfProfile = selfAgentId ? this.directory.profiles[selfAgentId] : null;
+    if (selfProfile) {
+      next.profiles[selfAgentId] = selfProfile;
+      const selfPresence = this.directory.presence[selfAgentId];
+      if (typeof selfPresence === "number" && Number.isFinite(selfPresence)) {
+        next.presence[selfAgentId] = selfPresence;
+      }
+      const rebuilt = rebuildIndexForProfile(next, selfProfile);
+      next.index = rebuilt.index;
+    }
+
+    for (const profile of keptRemoteProfiles) {
+      next.profiles[profile.agent_id] = profile;
+      const seenAt = this.directory.presence[profile.agent_id];
+      if (typeof seenAt === "number" && Number.isFinite(seenAt)) {
+        next.presence[profile.agent_id] = seenAt;
+      }
+      const rebuilt = rebuildIndexForProfile(next, profile);
+      next.index = rebuilt.index;
+    }
+
+    this.directory = dedupeIndex(next);
+    return removedIds.length;
+  }
+
   private compactCacheInMemory(): number {
     const cleaned = cleanupExpiredPresence(this.directory, Date.now(), PRESENCE_TTL_MS);
     this.directory = dedupeIndex(cleaned.state);
+    this.pruneRemoteProfilesInMemory();
     return cleaned.removed;
   }
 
@@ -3411,6 +3577,48 @@ export async function main() {
     sendOk(res, node.getRuntimePaths());
   });
 
+  app.get("/api/app/update-status", (_req, res) => {
+    sendOk(res, node.getAppUpdateStatus());
+  });
+
+  app.post(
+    "/api/app/update",
+    asyncRoute(async (_req, res) => {
+      const status = node.getAppUpdateStatus();
+      if (!status.update_available || !status.latest_version) {
+        sendOk(
+          res,
+          {
+            started: false,
+            current_version: status.current_version,
+            latest_version: status.latest_version,
+            platform: status.platform,
+            reason: status.check_error || "already_current",
+          },
+          { message: "Already on the latest version" }
+        );
+        return;
+      }
+      sendOk(
+        res,
+        {
+          started: true,
+          current_version: status.current_version,
+          target_version: status.latest_version,
+          platform: status.platform,
+        },
+        { message: `Updating to ${status.latest_version}` }
+      );
+      setTimeout(() => {
+        try {
+          node.startAppUpdate();
+        } catch {
+          // best effort after response has been sent
+        }
+      }, 150);
+    })
+  );
+
   app.put(
     "/api/profile",
     asyncRoute(async (req, res) => {

package/openclaw-skills/silicaclaw-broadcast/VERSION

@@ -1 +1 @@
-2026.3.20-beta.3
+2026.3.20-beta.4

package/openclaw-skills/silicaclaw-broadcast/manifest.json

@@ -1,6 +1,6 @@
 {
   "name": "silicaclaw-broadcast",
-  "version": "2026.3.20-beta.3",
+  "version": "2026.3.20-beta.4",
   "display_name": "SilicaClaw Broadcast",
   "description": "Official OpenClaw skill for a bounded local SilicaClaw broadcast workflow: read public broadcasts, publish public broadcasts, and optionally forward owner-relevant summaries through OpenClaw's native channel.",
   "entrypoints": {

package/openclaw-skills/silicaclaw-owner-push/VERSION

@@ -1 +1 @@
-2026.3.20-beta.1
+2026.3.20-beta.2

package/openclaw-skills/silicaclaw-owner-push/manifest.json

@@ -1,6 +1,6 @@
 {
   "name": "silicaclaw-owner-push",
-  "version": "2026.3.20-beta.1",
+  "version": "2026.3.20-beta.2",
   "display_name": "SilicaClaw Owner Push",
   "description": "Official OpenClaw skill for a bounded local SilicaClaw monitoring workflow: watch public broadcasts, filter owner-relevant updates, and push concise summaries through OpenClaw's native owner channel.",
   "entrypoints": {

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

@@ -19,6 +19,7 @@ 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
@@ -33,6 +34,8 @@ Override it with:
 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

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-3",
+  "version": "2026.3.20-4",
   "private": false,
   "publishConfig": {
     "access": "public"

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();