@silicaclaw/cli 2026.3.18-4 → 2026.3.19-2

package/scripts/openclaw-runtime-demo.mjs

@@ -0,0 +1,202 @@
+#!/usr/bin/env node
+
+import readline from "node:readline";
+import { createOpenClawBridgeClient } from "./openclaw-bridge-adapter.mjs";
+
+const apiBase = String(process.env.SILICACLAW_API_BASE || "http://localhost:4310").replace(/\/+$/, "");
+const bridge = createOpenClawBridgeClient({ apiBase });
+
+const COLOR = {
+  reset: "\x1b[0m",
+  bold: "\x1b[1m",
+  dim: "\x1b[2m",
+  orange: "\x1b[38;5;208m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  red: "\x1b[31m",
+  cyan: "\x1b[36m",
+};
+
+function useColor() {
+  return Boolean(process.stdout.isTTY && !process.env.NO_COLOR);
+}
+
+function paint(text, ...styles) {
+  if (!useColor() || styles.length === 0) return text;
+  return `${styles.join("")}${text}${COLOR.reset}`;
+}
+
+function line(text = "") {
+  process.stdout.write(`${text}\n`);
+}
+
+function printBanner() {
+  line(`${paint("OpenClaw Runtime Demo", COLOR.bold, COLOR.orange)}`);
+  line(paint("Bridge-backed sample process for SilicaClaw message broadcast.", COLOR.dim));
+  line("");
+}
+
+function printHelp() {
+  line(paint("Commands", COLOR.bold));
+  line("/help               Show this help");
+  line("/status             Refresh and print bridge status");
+  line("/profile            Print resolved profile payload");
+  line("/messages           Print recent messages");
+  line("/send <text>        Send message");
+  line("/quit               Exit");
+  line("");
+  line(paint("Tip", COLOR.bold));
+  line("Any non-command line will be sent as a public message.");
+  line("");
+}
+
+function formatMessagePrefix(item) {
+  const when = item.created_at ? new Date(item.created_at).toLocaleTimeString() : "-";
+  const name = item.display_name || "(unnamed)";
+  const status = item.online ? paint("online", COLOR.green) : paint("offline", COLOR.yellow);
+  return `${paint("[message]", COLOR.bold, COLOR.cyan)} ${name} ${paint(when, COLOR.dim)} ${status}`;
+}
+
+async function showStatus() {
+  const status = await bridge.getStatus();
+  line(paint("Bridge Status", COLOR.bold));
+  line(`api_base: ${apiBase}`);
+  line(`enabled: ${status.enabled}`);
+  line(`connected_to_silicaclaw: ${status.connected_to_silicaclaw}`);
+  line(`public_enabled: ${status.public_enabled}`);
+  line(`message_broadcast_enabled: ${status.message_broadcast_enabled}`);
+  line(`network_mode: ${status.network_mode}`);
+  line(`adapter: ${status.adapter}`);
+  line(`agent_id: ${status.agent_id || "-"}`);
+  line(`display_name: ${status.display_name || "-"}`);
+  line("");
+}
+
+async function showProfile() {
+  const profile = await bridge.getProfile();
+  line(paint("Bridge Profile", COLOR.bold));
+  line(JSON.stringify(profile, null, 2));
+  line("");
+}
+
+async function showMessages(limit = 10) {
+  const payload = await bridge.listMessages({ limit });
+  const items = Array.isArray(payload?.items) ? payload.items : [];
+  line(paint(`Recent Messages (${items.length})`, COLOR.bold));
+  if (!items.length) {
+    line(paint("No public messages.", COLOR.dim));
+    line("");
+    return;
+  }
+  for (const item of items) {
+    line(formatMessagePrefix(item));
+    line(item.body || "");
+    line("");
+  }
+}
+
+async function sendMessage(body) {
+  const text = String(body || "").trim();
+  if (!text) {
+    line(paint("Cannot send an empty message.", COLOR.yellow));
+    return;
+  }
+  const result = await bridge.sendMessage(text);
+  if (result.sent) {
+    line(`${paint("[sent]", COLOR.bold, COLOR.green)} ${text}`);
+  } else {
+    line(`${paint("[skipped]", COLOR.bold, COLOR.yellow)} ${result.reason}`);
+  }
+  line("");
+}
+
+async function startWatcher() {
+  for await (const item of bridge.watchMessages({ limit: 12, intervalSec: 5 })) {
+    line(formatMessagePrefix(item));
+    line(item.body || "");
+    line("");
+    rl.prompt(true);
+  }
+}
+
+async function handleCommand(input) {
+  const trimmed = String(input || "").trim();
+  if (!trimmed) {
+    return;
+  }
+  if (!trimmed.startsWith("/")) {
+    await sendMessage(trimmed);
+    return;
+  }
+
+  const [command, ...rest] = trimmed.split(/\s+/);
+  if (command === "/help") {
+    printHelp();
+    return;
+  }
+  if (command === "/status") {
+    await showStatus();
+    return;
+  }
+  if (command === "/profile") {
+    await showProfile();
+    return;
+  }
+  if (command === "/messages") {
+    await showMessages();
+    return;
+  }
+  if (command === "/send") {
+    await sendMessage(rest.join(" "));
+    return;
+  }
+  if (command === "/quit" || command === "/exit") {
+    rl.close();
+    return;
+  }
+
+  line(paint(`Unknown command: ${command}`, COLOR.red));
+  line("");
+}
+
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout,
+  prompt: paint("openclaw-demo> ", COLOR.bold),
+});
+
+async function main() {
+  printBanner();
+  printHelp();
+  try {
+    await showStatus();
+  } catch (error) {
+    line(paint(`Bridge unavailable: ${error instanceof Error ? error.message : String(error)}`, COLOR.red));
+    line(paint("Start local-console first, then rerun this demo.", COLOR.dim));
+    process.exit(1);
+  }
+
+  void startWatcher().catch((error) => {
+    line(paint(`Watcher stopped: ${error instanceof Error ? error.message : String(error)}`, COLOR.red));
+  });
+
+  rl.prompt();
+  rl.on("line", async (input) => {
+    try {
+      await handleCommand(input);
+    } catch (error) {
+      line(paint(`Command failed: ${error instanceof Error ? error.message : String(error)}`, COLOR.red));
+      line("");
+    }
+    rl.prompt();
+  });
+  rl.on("close", () => {
+    line(paint("OpenClaw runtime demo stopped.", COLOR.dim));
+    process.exit(0);
+  });
+}
+
+main().catch((error) => {
+  line(paint(`Runtime demo failed: ${error instanceof Error ? error.message : String(error)}`, COLOR.red));
+  process.exit(1);
+});

package/scripts/pack-openclaw-skill.mjs

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const ROOT_DIR = resolve(__dirname, "..");
+
+function parseFlag(name, fallback = "") {
+  const prefix = `--${name}=`;
+  for (const item of process.argv.slice(2)) {
+    if (item.startsWith(prefix)) return item.slice(prefix.length);
+  }
+  return fallback;
+}
+
+function main() {
+  const skillName = parseFlag("skill", "silicaclaw-broadcast");
+  const skillsRoot = resolve(ROOT_DIR, "openclaw-skills");
+  const skillDir = resolve(skillsRoot, skillName);
+  if (!existsSync(skillDir)) {
+    throw new Error(`Skill not found: ${skillName}`);
+  }
+
+  const outDir = resolve(ROOT_DIR, "dist", "openclaw-skills");
+  mkdirSync(outDir, { recursive: true });
+  const archivePath = resolve(outDir, `${skillName}.tgz`);
+
+  const result = spawnSync("tar", ["-czf", archivePath, "-C", skillsRoot, skillName], {
+    cwd: ROOT_DIR,
+    stdio: "pipe",
+    encoding: "utf8",
+  });
+  if (result.error) {
+    throw result.error;
+  }
+  if ((result.status ?? 1) !== 0) {
+    throw new Error(String(result.stderr || result.stdout || "tar failed").trim());
+  }
+
+  const digest = createHash("sha256").update(readFileSync(archivePath)).digest("hex");
+  const checksumPath = `${archivePath}.sha256`;
+  writeFileSync(checksumPath, `${digest}  ${resolve(outDir, `${skillName}.tgz`).split("/").pop()}\n`, "utf8");
+
+  console.log(JSON.stringify({
+    skill: skillName,
+    source_dir: skillDir,
+    archive_path: archivePath,
+    sha256: digest,
+    checksum_path: checksumPath,
+  }, null, 2));
+}
+
+main();

package/scripts/silicaclaw-cli.mjs

@@ -484,6 +484,11 @@ function help() {
   kv("Update", "silicaclaw update");
   kv("Onboard", "silicaclaw onboard");
   kv("Connect", "silicaclaw connect");
+  kv("OpenClaw Demo", "silicaclaw openclaw-demo");
+  kv("OpenClaw Bridge", "silicaclaw openclaw-bridge status");
+  kv("OpenClaw Skill", "silicaclaw openclaw-skill-install");
+  kv("Pack Skill", "silicaclaw openclaw-skill-pack");
+  kv("Check Skill", "silicaclaw openclaw-skill-validate");
   kv("Logs", "silicaclaw logs local-console");
   kv("Doctor", "silicaclaw doctor");
   kv("Help", "silicaclaw help");
@@ -515,6 +520,31 @@ switch (cmd) {
       cwd: process.cwd(),
     });
     break;
+  case "openclaw-demo":
+    run("node", [resolve(ROOT_DIR, "scripts", "openclaw-runtime-demo.mjs"), ...process.argv.slice(3)], {
+      cwd: process.cwd(),
+    });
+    break;
+  case "openclaw-bridge":
+    run("node", [resolve(ROOT_DIR, "scripts", "openclaw-bridge-client.mjs"), ...process.argv.slice(3)], {
+      cwd: process.cwd(),
+    });
+    break;
+  case "openclaw-skill-install":
+    run("node", [resolve(ROOT_DIR, "scripts", "install-openclaw-skill.mjs"), ...process.argv.slice(3)], {
+      cwd: process.cwd(),
+    });
+    break;
+  case "openclaw-skill-pack":
+    run("node", [resolve(ROOT_DIR, "scripts", "pack-openclaw-skill.mjs"), ...process.argv.slice(3)], {
+      cwd: process.cwd(),
+    });
+    break;
+  case "openclaw-skill-validate":
+    run("node", [resolve(ROOT_DIR, "scripts", "validate-openclaw-skill.mjs"), ...process.argv.slice(3)], {
+      cwd: process.cwd(),
+    });
+    break;
   case "start":
   case "stop":
   case "restart":

package/scripts/silicaclaw-gateway.mjs

@@ -118,11 +118,18 @@ const CONSOLE_LOG_FILE = join(STATE_DIR, "local-console.log");
 const SIGNALING_PID_FILE = join(STATE_DIR, "signaling.pid");
 const SIGNALING_LOG_FILE = join(STATE_DIR, "signaling.log");
 const STATE_FILE = join(STATE_DIR, "state.json");
+const LAUNCH_AGENTS_DIR = join(homedir(), "Library", "LaunchAgents");
+const LOCAL_CONSOLE_LABEL = "ai.silicaclaw.local-console";
+const SIGNALING_LABEL = "ai.silicaclaw.signaling";
 
 function ensureStateDir() {
   mkdirSync(STATE_DIR, { recursive: true });
 }
 
+function ensureLaunchAgentsDir() {
+  mkdirSync(LAUNCH_AGENTS_DIR, { recursive: true });
+}
+
 function readPid(file) {
   if (!existsSync(file)) return null;
   const text = String(readFileSync(file, "utf8")).trim();
@@ -192,6 +199,118 @@ function parseUrlHostPort(url) {
   }
 }
 
+function isLaunchdPlatform() {
+  return process.platform === "darwin" && !hasFlag("no-launchd");
+}
+
+function launchdDomain() {
+  const uid = typeof process.getuid === "function" ? process.getuid() : 0;
+  return `gui/${uid}`;
+}
+
+function launchAgentPlistPath(label) {
+  return join(LAUNCH_AGENTS_DIR, `${label}.plist`);
+}
+
+function plistEscape(value) {
+  return String(value || "")
+    .replaceAll("&", "&")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replaceAll('"', "&quot;")
+    .replaceAll("'", "&apos;");
+}
+
+function buildLaunchAgentPlist({ label, programArguments, workingDirectory, stdoutPath, stderrPath, environment }) {
+  const argsXml = programArguments.map((arg) => `\n      <string>${plistEscape(arg)}</string>`).join("");
+  const envEntries = Object.entries(environment || {}).filter(([, value]) => String(value || "").trim());
+  const envXml = envEntries.length
+    ? `\n    <key>EnvironmentVariables</key>\n    <dict>${envEntries
+        .map(([key, value]) => `\n      <key>${plistEscape(key)}</key>\n      <string>${plistEscape(value)}</string>`)
+        .join("")}\n    </dict>`
+    : "";
+  return `<?xml version="1.0" encoding="UTF-8"?>\n<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">\n<plist version="1.0">\n  <dict>\n    <key>Label</key>\n    <string>${plistEscape(label)}</string>\n    <key>RunAtLoad</key>\n    <true/>\n    <key>KeepAlive</key>\n    <true/>\n    <key>ThrottleInterval</key>\n    <integer>1</integer>\n    <key>ProgramArguments</key>\n    <array>${argsXml}\n    </array>\n    <key>WorkingDirectory</key>\n    <string>${plistEscape(workingDirectory)}</string>\n    <key>StandardOutPath</key>\n    <string>${plistEscape(stdoutPath)}</string>\n    <key>StandardErrorPath</key>\n    <string>${plistEscape(stderrPath)}</string>${envXml}\n  </dict>\n</plist>\n`;
+}
+
+function runLaunchctl(args) {
+  return spawnSync("launchctl", args, {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+}
+
+function resolveCommandPath(command) {
+  const result = spawnSync("which", [command], {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "ignore"],
+  });
+  if ((result.status ?? 1) === 0) {
+    const value = String(result.stdout || "").trim();
+    if (value) return value;
+  }
+  return command;
+}
+
+function isLaunchAgentLoaded(label) {
+  const result = runLaunchctl(["print", `${launchdDomain()}/${label}`]);
+  return (result.status ?? 1) === 0;
+}
+
+function readLaunchAgentRuntime(label) {
+  const result = runLaunchctl(["print", `${launchdDomain()}/${label}`]);
+  if ((result.status ?? 1) !== 0) return { loaded: false, pid: null };
+  const text = `${result.stdout || ""}\n${result.stderr || ""}`;
+  const pidMatch = text.match(/pid = (\d+)/);
+  return {
+    loaded: true,
+    pid: pidMatch ? Number(pidMatch[1]) : null,
+  };
+}
+
+function installLaunchAgent({ label, programArguments, workingDirectory, logFile, environment }) {
+  ensureLaunchAgentsDir();
+  ensureStateDir();
+  const plistPath = launchAgentPlistPath(label);
+  const plist = buildLaunchAgentPlist({
+    label,
+    programArguments,
+    workingDirectory,
+    stdoutPath: logFile,
+    stderrPath: logFile,
+    environment,
+  });
+  writeFileSync(plistPath, plist, "utf8");
+
+  if (isLaunchAgentLoaded(label)) {
+    runLaunchctl(["bootout", launchdDomain(), plistPath]);
+  }
+
+  const result = runLaunchctl(["bootstrap", launchdDomain(), plistPath]);
+  if ((result.status ?? 1) !== 0) {
+    const detail = String(result.stderr || result.stdout || "launchctl bootstrap failed").trim();
+    throw new Error(detail);
+  }
+}
+
+function stopLaunchAgent(label) {
+  const plistPath = launchAgentPlistPath(label);
+  if (!existsSync(plistPath) && !isLaunchAgentLoaded(label)) return;
+  const result = runLaunchctl(["bootout", launchdDomain(), plistPath]);
+  if ((result.status ?? 1) !== 0 && isLaunchAgentLoaded(label)) {
+    const detail = String(result.stderr || result.stdout || "launchctl bootout failed").trim();
+    throw new Error(detail);
+  }
+}
+
+function uninstallLaunchAgent(label) {
+  try {
+    stopLaunchAgent(label);
+  } catch {
+    // ignore best-effort cleanup
+  }
+  removeFileIfExists(launchAgentPlistPath(label));
+}
+
 function spawnBackground(command, args, env, logFile, pidFile, cwd = APP_DIR) {
   const outFd = openSync(logFile, "a");
   const child = spawn(command, args, {
@@ -230,7 +349,41 @@ function printHelp() {
   kv("Logs", "silicaclaw gateway logs local-console");
 }
 
+function launchdStatusPayload() {
+  const state = readState();
+  const localRuntime = readLaunchAgentRuntime(LOCAL_CONSOLE_LABEL);
+  const signalingRuntime = readLaunchAgentRuntime(SIGNALING_LABEL);
+  const localListener = listeningProcessOnPort(4310);
+  const signalingListener = listeningProcessOnPort(4510);
+  return {
+    app_dir: APP_DIR,
+    mode: state?.mode || "unknown",
+    adapter: state?.adapter || "unknown",
+    service_manager: "launchd",
+    local_console: {
+      pid: Number(localListener?.pid || localRuntime.pid || 0) || null,
+      running: Boolean(localListener) || Boolean(localRuntime.loaded && localRuntime.pid),
+      loaded: localRuntime.loaded,
+      label: LOCAL_CONSOLE_LABEL,
+      log_file: CONSOLE_LOG_FILE,
+    },
+    signaling: {
+      pid: Number(signalingListener?.pid || signalingRuntime.pid || 0) || null,
+      running: Boolean(signalingListener) || Boolean(signalingRuntime.loaded && signalingRuntime.pid),
+      loaded: signalingRuntime.loaded,
+      label: SIGNALING_LABEL,
+      log_file: SIGNALING_LOG_FILE,
+      url: state?.signaling_url || null,
+      room: state?.room || null,
+    },
+    updated_at: state?.updated_at || null,
+  };
+}
+
 function buildStatusPayload() {
+  if (isLaunchdPlatform()) {
+    return launchdStatusPayload();
+  }
   const localPid = readPid(CONSOLE_PID_FILE);
   const sigPid = readPid(SIGNALING_PID_FILE);
   const state = readState();
@@ -414,6 +567,19 @@ function tailFile(file, lines = 80) {
 }
 
 async function stopAll() {
+  if (isLaunchdPlatform()) {
+    stopLaunchAgent(LOCAL_CONSOLE_LABEL);
+    stopLaunchAgent(SIGNALING_LABEL);
+    await stopOwnedListener(4310, "local-console");
+    await stopOwnedListener(4510, "signaling");
+    removeFileIfExists(CONSOLE_PID_FILE);
+    removeFileIfExists(SIGNALING_PID_FILE);
+    writeState({
+      ...(readState() || {}),
+      updated_at: Date.now(),
+    });
+    return;
+  }
   const localPid = readPid(CONSOLE_PID_FILE);
   const sigPid = readPid(SIGNALING_PID_FILE);
   await stopPid(localPid, "local-console");
@@ -469,6 +635,55 @@ async function startAll() {
     !shouldDisableSignaling &&
     (host === "localhost" || host === "127.0.0.1");
 
+  if (isLaunchdPlatform()) {
+    const npmPath = resolveCommandPath("npm");
+    const signalingEntry = resolve(APP_DIR, "scripts", "webrtc-signaling-server.mjs");
+    await stopOwnedListener(4310, "local-console");
+    await stopOwnedListener(4510, "signaling");
+    const baseEnv = {
+      NETWORK_ADAPTER: adapter,
+      NETWORK_MODE: mode,
+      WEBRTC_SIGNALING_URL: signalingUrl,
+      WEBRTC_ROOM: room,
+      PATH: process.env.PATH || "/usr/bin:/bin:/usr/sbin:/sbin",
+      HOME: process.env.HOME || homedir(),
+    };
+
+    installLaunchAgent({
+      label: LOCAL_CONSOLE_LABEL,
+      programArguments: [npmPath, "run", "--workspace", "@silicaclaw/local-console", "start"],
+      workingDirectory: APP_DIR,
+      logFile: CONSOLE_LOG_FILE,
+      environment: baseEnv,
+    });
+
+    if (shouldAutoStartSignaling) {
+      installLaunchAgent({
+        label: SIGNALING_LABEL,
+        programArguments: [process.execPath, signalingEntry],
+        workingDirectory: APP_DIR,
+        logFile: SIGNALING_LOG_FILE,
+        environment: {
+          PATH: baseEnv.PATH,
+          HOME: baseEnv.HOME,
+          PORT: String(port),
+        },
+      });
+    } else {
+      uninstallLaunchAgent(SIGNALING_LABEL);
+    }
+
+    writeState({
+      app_dir: APP_DIR,
+      mode,
+      adapter,
+      signaling_url: signalingUrl,
+      room,
+      updated_at: Date.now(),
+    });
+    return { localPid: null, signalingPid: null };
+  }
+
   let signalingPid = currentSigPid;
   if (shouldAutoStartSignaling) {
     if (!isRunning(currentSigPid)) {

package/scripts/validate-openclaw-skill.mjs

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const ROOT_DIR = resolve(__dirname, "..");
+
+function assert(condition, message) {
+  if (!condition) throw new Error(message);
+}
+
+function parseFlag(name, fallback = "") {
+  const prefix = `--${name}=`;
+  for (const item of process.argv.slice(2)) {
+    if (item.startsWith(prefix)) return item.slice(prefix.length);
+  }
+  return fallback;
+}
+
+function main() {
+  const skillName = parseFlag("skill", "silicaclaw-broadcast");
+  const skillDir = resolve(ROOT_DIR, "openclaw-skills", skillName);
+  const skillMd = resolve(skillDir, "SKILL.md");
+  const versionFile = resolve(skillDir, "VERSION");
+  const manifestFile = resolve(skillDir, "manifest.json");
+  const agentYaml = resolve(skillDir, "agents", "openai.yaml");
+  const clientFile = resolve(skillDir, "scripts", "bridge-client.mjs");
+  const ownerForwarderDemoFile = resolve(skillDir, "scripts", "owner-forwarder-demo.mjs");
+  const ownerDispatchAdapterDemoFile = resolve(skillDir, "scripts", "owner-dispatch-adapter-demo.mjs");
+  const ownerSendViaOpenClawFile = resolve(skillDir, "scripts", "send-to-owner-via-openclaw.mjs");
+  const ownerPolicyFile = resolve(skillDir, "references", "owner-forwarding-policy.md");
+  const ownerDispatchAdapterRefFile = resolve(skillDir, "references", "owner-dispatch-adapter.md");
+  const computerControlRefFile = resolve(skillDir, "references", "computer-control-via-openclaw.md");
+
+  for (const filePath of [skillMd, versionFile, manifestFile, agentYaml, clientFile, ownerForwarderDemoFile, ownerDispatchAdapterDemoFile, ownerSendViaOpenClawFile, ownerPolicyFile, ownerDispatchAdapterRefFile, computerControlRefFile]) {
+    assert(existsSync(filePath), `Missing required skill file: ${filePath}`);
+  }
+
+  const skillBody = readFileSync(skillMd, "utf8");
+  const version = readFileSync(versionFile, "utf8").trim();
+  const manifest = JSON.parse(readFileSync(manifestFile, "utf8"));
+  const ui = readFileSync(agentYaml, "utf8");
+  const ownerPolicy = readFileSync(ownerPolicyFile, "utf8");
+  const ownerDispatchAdapterRef = readFileSync(ownerDispatchAdapterRefFile, "utf8");
+  const computerControlRef = readFileSync(computerControlRefFile, "utf8");
+
+  assert(skillBody.includes(`name: ${skillName}`), "SKILL.md name metadata mismatch");
+  assert(Boolean(version), "VERSION is empty");
+  assert(manifest.name === skillName, "manifest name mismatch");
+  assert(manifest.version === version, "manifest version does not match VERSION");
+  assert(String(manifest.entrypoints?.skill || "") === "SKILL.md", "manifest skill entrypoint mismatch");
+  assert(String(manifest.entrypoints?.owner_forwarder_demo || "") === "scripts/owner-forwarder-demo.mjs", "manifest owner forwarder demo entrypoint mismatch");
+  assert(String(manifest.entrypoints?.owner_dispatch_adapter_demo || "") === "scripts/owner-dispatch-adapter-demo.mjs", "manifest owner dispatch adapter demo entrypoint mismatch");
+  assert(String(manifest.entrypoints?.owner_send_via_openclaw || "") === "scripts/send-to-owner-via-openclaw.mjs", "manifest owner send via openclaw entrypoint mismatch");
+  assert(String(manifest.references?.owner_forwarding_policy || "") === "references/owner-forwarding-policy.md", "manifest owner forwarding reference mismatch");
+  assert(String(manifest.references?.owner_dispatch_adapter || "") === "references/owner-dispatch-adapter.md", "manifest owner dispatch adapter reference mismatch");
+  assert(String(manifest.references?.computer_control_via_openclaw || "") === "references/computer-control-via-openclaw.md", "manifest computer control reference mismatch");
+  assert(ui.includes('display_name: "SilicaClaw Broadcast"'), "openai.yaml display_name mismatch");
+  assert(ownerPolicy.includes("Default routing modes"), "owner forwarding policy content mismatch");
+  assert(ownerDispatchAdapterRef.includes("OPENCLAW_OWNER_FORWARD_CMD"), "owner dispatch adapter reference content mismatch");
+  assert(computerControlRef.includes("node.invoke"), "computer control reference content mismatch");
+
+  console.log(JSON.stringify({
+    valid: true,
+    skill: skillName,
+    version,
+    skill_dir: skillDir,
+  }, null, 2));
+}
+
+main();

package/social.md.example

@@ -12,6 +12,12 @@ identity:
 network:
   mode: "lan"
 
+discovery:
+  discoverable: true
+  allow_profile_broadcast: true
+  allow_presence_broadcast: true
+  allow_message_broadcast: true
+
 openclaw:
   bind_existing_identity: true
   use_openclaw_profile_if_available: true