@silicaclaw/cli 1.0.0-beta.9 → 2026.3.18-3

package/scripts/silicaclaw-gateway.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-import { spawn } from "node:child_process";
+import { spawn, spawnSync } from "node:child_process";
 import { existsSync, mkdirSync, openSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
@@ -13,6 +13,72 @@ const ROOT_DIR = resolve(__dirname, "..");
 const argv = process.argv.slice(2);
 const cmd = String(argv[0] || "help").toLowerCase();
 
+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",
+};
+
+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 displayVersion(raw) {
+  const text = String(raw || "unknown").trim() || "unknown";
+  return text.startsWith("v") ? text : `v${text}`;
+}
+
+function headline() {
+  const pkgPath = join(ROOT_DIR, "package.json");
+  let version = "unknown";
+  if (existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(String(readFileSync(pkgPath, "utf8")));
+      version = String(pkg.version || "unknown");
+    } catch {
+      version = "unknown";
+    }
+  }
+  console.log(`${paint("SilicaClaw", COLOR.bold, COLOR.orange)} ${paint(displayVersion(version), COLOR.dim)}`);
+  console.log(paint("Public identity and discovery for OpenClaw agents.", COLOR.dim));
+}
+
+function kv(label, value) {
+  console.log(`${paint(label.padEnd(14), COLOR.dim)} ${value}`);
+}
+
+function section(title) {
+  console.log(paint(title, COLOR.bold));
+}
+
+function readJson(file) {
+  try {
+    return JSON.parse(String(readFileSync(file, "utf8")));
+  } catch {
+    return null;
+  }
+}
+
+function isSilicaClawDir(dir) {
+  const pkgPath = join(dir, "package.json");
+  if (!existsSync(pkgPath)) return false;
+  const pkg = readJson(pkgPath);
+  if (!pkg || typeof pkg !== "object") return false;
+  const name = String(pkg.name || "");
+  if (name === "@silicaclaw/cli" || name === "silicaclaw") return true;
+  const scripts = pkg.scripts && typeof pkg.scripts === "object" ? pkg.scripts : {};
+  return Boolean(scripts.gateway || scripts["local-console"] || scripts["public-explorer"]);
+}
+
 function parseFlag(name, fallback = "") {
   const prefix = `--${name}=`;
   for (const item of argv) {
@@ -27,17 +93,17 @@ function hasFlag(name) {
 
 function detectAppDir() {
   const envDir = process.env.SILICACLAW_APP_DIR;
-  if (envDir && existsSync(join(envDir, "package.json"))) {
+  if (envDir && isSilicaClawDir(envDir)) {
     return resolve(envDir);
   }
 
   const cwd = process.cwd();
-  if (existsSync(join(cwd, "package.json"))) {
+  if (isSilicaClawDir(cwd)) {
     return resolve(cwd);
   }
 
   const homeCandidate = join(homedir(), "silicaclaw");
-  if (existsSync(join(homeCandidate, "package.json"))) {
+  if (isSilicaClawDir(homeCandidate)) {
     return resolve(homeCandidate);
   }
 
@@ -97,7 +163,7 @@ async function stopPid(pid, name) {
     }
   }
   if (isRunning(pid)) {
-    console.error(`failed to stop ${name} (pid=${pid})`);
+    console.error(`${paint("Failed to stop", COLOR.bold, COLOR.red)} ${name} (pid=${pid})`);
   }
 }
 
@@ -109,7 +175,7 @@ function parseMode(raw) {
 
 function adapterForMode(mode) {
   if (mode === "lan") return "real-preview";
-  if (mode === "global-preview") return "webrtc-preview";
+  if (mode === "global-preview") return "relay-preview";
   return "local-event-bus";
 }
 
@@ -153,53 +219,166 @@ function readState() {
 }
 
 function printHelp() {
-  console.log(`
-SilicaClaw Gateway
-
-Usage:
-  silicaclaw gateway start [--mode=local|lan|global-preview] [--signaling-url=http://host:4510] [--room=silicaclaw-demo]
-  silicaclaw gateway stop
-  silicaclaw gateway restart [--mode=...]
-  silicaclaw gateway status
-  silicaclaw gateway logs [local-console|signaling]
-
-Notes:
-  - Default app dir: current directory; fallback: ~/silicaclaw
-  - State dir: .silicaclaw/gateway
-  - global-preview + localhost signaling URL will auto-start signaling server
-`.trim());
+  headline();
+  console.log("");
+  section("Gateway");
+  kv("Start", "silicaclaw gateway start");
+  kv("Stop", "silicaclaw gateway stop");
+  kv("Restart", "silicaclaw gateway restart");
+  kv("Status", "silicaclaw gateway status");
+  kv("Logs", "silicaclaw gateway logs local-console");
 }
 
-function showStatus() {
+function buildStatusPayload() {
   const localPid = readPid(CONSOLE_PID_FILE);
   const sigPid = readPid(SIGNALING_PID_FILE);
   const state = readState();
-  const payload = {
+  const localListener = listeningProcessOnPort(4310);
+  const signalingListener = listeningProcessOnPort(4510);
+  return {
     app_dir: APP_DIR,
     mode: state?.mode || "unknown",
     adapter: state?.adapter || "unknown",
     local_console: {
       pid: localPid,
-      running: isRunning(localPid),
+      running: Boolean(localListener),
       log_file: CONSOLE_LOG_FILE,
     },
     signaling: {
       pid: sigPid,
-      running: isRunning(sigPid),
+      running: Boolean(signalingListener),
       log_file: SIGNALING_LOG_FILE,
       url: state?.signaling_url || null,
       room: state?.room || null,
     },
     updated_at: state?.updated_at || null,
   };
-  console.log(JSON.stringify(payload, null, 2));
+}
+
+function showStatusJson() {
+  console.log(JSON.stringify(buildStatusPayload(), null, 2));
+}
+
+function showStatusHuman() {
+  const payload = buildStatusPayload();
+  headline();
+  console.log("");
+  kv(
+    "Status",
+    payload.local_console.running
+      ? `${paint("running", COLOR.green)} · ${payload.mode}`
+      : `${paint("stopped", COLOR.dim)} · ${payload.mode}`
+  );
+  if (payload.mode === "global-preview") {
+    kv("Relay", payload.signaling.url || "https://relay.silicaclaw.com");
+    kv("Room", payload.signaling.room || "silicaclaw-global-preview");
+  }
+  if (payload.local_console.running) kv("Open", "http://localhost:4310");
+  return payload;
+}
+
+function printConnectionSummary(status, verb = "Started") {
+  if (!status?.local_console?.running) return;
+  headline();
+  console.log("");
+  kv("Status", `${verb.toLowerCase()} · ${status.mode}`);
+  kv("Console", `http://localhost:4310`);
+  if (status.mode === "global-preview") {
+    const signalingUrl = status?.signaling?.url || "https://relay.silicaclaw.com";
+    const room = status?.signaling?.room || "silicaclaw-global-preview";
+    kv("Relay", signalingUrl);
+    kv("Room", room);
+  }
+}
+
+function listeningProcessOnPort(port) {
+  try {
+    const pidRes = spawnSync("lsof", ["-nP", `-iTCP:${port}`, "-sTCP:LISTEN", "-t"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+    });
+    const pid = String(pidRes.stdout || "")
+      .split(/\r?\n/)
+      .map((s) => s.trim())
+      .find(Boolean);
+    if (!pid) return null;
+
+    const cmdRes = spawnSync("ps", ["-p", pid, "-o", "command="], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+    });
+    const command = String(cmdRes.stdout || "").trim() || "unknown";
+    return { pid, command };
+  } catch {
+    return null;
+  }
+}
+
+function normalizePathForMatch(value) {
+  return String(value || "").replace(/\\/g, "/");
+}
+
+function isOwnedListener(listener, kind) {
+  if (!listener?.command) return false;
+  const command = normalizePathForMatch(listener.command).toLowerCase();
+  const appDir = normalizePathForMatch(APP_DIR).toLowerCase();
+  const rootDir = normalizePathForMatch(ROOT_DIR).toLowerCase();
+  const inWorkspace = command.includes(appDir) || command.includes(rootDir);
+  if (!inWorkspace) return false;
+  if (kind === "local-console") {
+    return (
+      command.includes("@silicaclaw/local-console") ||
+      command.includes("/apps/local-console/") ||
+      command.includes("src/server.ts") ||
+      command.includes("dist/server.js")
+    );
+  }
+  if (kind === "signaling") {
+    return command.includes("webrtc-signaling-server.mjs") || command.includes("npm run webrtc-signaling");
+  }
+  return false;
+}
+
+async function stopOwnedListener(port, kind) {
+  const listener = listeningProcessOnPort(port);
+  if (!listener || !isOwnedListener(listener, kind)) return false;
+  await stopPid(Number(listener.pid), kind);
+  return true;
+}
+
+function printStopSummary() {
+  const localListener = listeningProcessOnPort(4310);
+  const signalingListener = listeningProcessOnPort(4510);
+  headline();
+  console.log("");
+  kv("Status", "stopped");
+  if (!localListener) {
+    kv("Console", paint("stopped", COLOR.green));
+  } else {
+    kv("Console", `${paint("still busy", COLOR.yellow)} (pid=${localListener.pid})`);
+    kv("Inspect", "lsof -nP -iTCP:4310 -sTCP:LISTEN");
+    kv("Stop pid", `kill ${localListener.pid}`);
+  }
+  if (!signalingListener) {
+    kv("Relay port", paint("stopped", COLOR.green));
+  } else {
+    kv("Relay port", `${paint("still busy", COLOR.yellow)} (pid=${signalingListener.pid})`);
+    kv("Inspect", "lsof -nP -iTCP:4510 -sTCP:LISTEN");
+    kv("Stop pid", `kill ${signalingListener.pid}`);
+  }
 }
 
 function tailFile(file, lines = 80) {
   if (!existsSync(file)) {
-    console.log(`log file not found: ${file}`);
+    headline();
+    console.log("");
+    kv("Logs", "not found");
     return;
   }
+  headline();
+  console.log("");
+  kv("Logs", file);
+  console.log("");
   const text = String(readFileSync(file, "utf8"));
   const out = text.split(/\r?\n/).slice(-lines).join("\n");
   console.log(out);
@@ -210,29 +389,29 @@ async function stopAll() {
   const sigPid = readPid(SIGNALING_PID_FILE);
   await stopPid(localPid, "local-console");
   await stopPid(sigPid, "signaling");
+  await stopOwnedListener(4310, "local-console");
+  await stopOwnedListener(4510, "signaling");
   removeFileIfExists(CONSOLE_PID_FILE);
   removeFileIfExists(SIGNALING_PID_FILE);
   writeState({
     ...(readState() || {}),
     updated_at: Date.now(),
   });
-  console.log("gateway stopped");
 }
 
 function startAll() {
   ensureStateDir();
 
-  const mode = parseMode(parseFlag("mode", process.env.NETWORK_MODE || "local"));
+  const mode = parseMode(parseFlag("mode", process.env.NETWORK_MODE || "global-preview"));
   const adapter = adapterForMode(mode);
-  const signalingUrl = parseFlag("signaling-url", process.env.WEBRTC_SIGNALING_URL || "http://localhost:4510");
-  const room = parseFlag("room", process.env.WEBRTC_ROOM || "silicaclaw-demo");
+  const signalingUrl = parseFlag("signaling-url", process.env.WEBRTC_SIGNALING_URL || "https://relay.silicaclaw.com");
+  const room = parseFlag("room", process.env.WEBRTC_ROOM || "silicaclaw-global-preview");
   const shouldDisableSignaling = hasFlag("no-signaling");
 
   const currentLocalPid = readPid(CONSOLE_PID_FILE);
   const currentSigPid = readPid(SIGNALING_PID_FILE);
-  if (isRunning(currentLocalPid)) {
-    console.log(`local-console already running (pid=${currentLocalPid})`);
-  } else {
+  let localPid = currentLocalPid;
+  if (!isRunning(currentLocalPid)) {
     removeFileIfExists(CONSOLE_PID_FILE);
     const env = {
       NETWORK_ADAPTER: adapter,
@@ -240,8 +419,7 @@ function startAll() {
       WEBRTC_SIGNALING_URL: signalingUrl,
       WEBRTC_ROOM: room,
     };
-    const pid = spawnBackground("npm", ["run", "local-console"], env, CONSOLE_LOG_FILE, CONSOLE_PID_FILE);
-    console.log(`local-console started (pid=${pid})`);
+    localPid = spawnBackground("npm", ["run", "local-console"], env, CONSOLE_LOG_FILE, CONSOLE_PID_FILE);
   }
 
   const { host, port } = parseUrlHostPort(signalingUrl);
@@ -250,19 +428,17 @@ function startAll() {
     !shouldDisableSignaling &&
     (host === "localhost" || host === "127.0.0.1");
 
+  let signalingPid = currentSigPid;
   if (shouldAutoStartSignaling) {
-    if (isRunning(currentSigPid)) {
-      console.log(`signaling already running (pid=${currentSigPid})`);
-    } else {
+    if (!isRunning(currentSigPid)) {
       removeFileIfExists(SIGNALING_PID_FILE);
-      const pid = spawnBackground(
+      signalingPid = spawnBackground(
         "npm",
         ["run", "webrtc-signaling"],
         { PORT: String(port) },
         SIGNALING_LOG_FILE,
         SIGNALING_PID_FILE,
       );
-      console.log(`signaling started (pid=${pid}, port=${port})`);
     }
   }
 
@@ -274,6 +450,7 @@ function startAll() {
     room,
     updated_at: Date.now(),
   });
+  return { localPid, signalingPid: shouldAutoStartSignaling ? signalingPid : null };
 }
 
 async function main() {
@@ -282,23 +459,29 @@ async function main() {
     return;
   }
   if (cmd === "status") {
-    showStatus();
+    if (hasFlag("json")) {
+      showStatusJson();
+    } else {
+      showStatusHuman();
+    }
     return;
   }
   if (cmd === "start") {
     startAll();
-    showStatus();
+    const status = buildStatusPayload();
+    printConnectionSummary(status, "Started");
     return;
   }
   if (cmd === "stop") {
     await stopAll();
-    showStatus();
+    printStopSummary();
     return;
   }
   if (cmd === "restart") {
     await stopAll();
     startAll();
-    showStatus();
+    const status = buildStatusPayload();
+    printConnectionSummary(status, "Restarted");
     return;
   }
   if (cmd === "logs") {
@@ -315,7 +498,9 @@ async function main() {
 }
 
 main().catch((error) => {
+  headline();
+  console.log("");
+  console.error(paint("Gateway command failed", COLOR.bold, COLOR.red));
   console.error(error?.message || String(error));
   process.exit(1);
 });
-

package/scripts/webrtc-signaling-server.mjs

@@ -5,8 +5,9 @@ import { randomUUID, createHash } from 'crypto';
 const port = Number(process.env.PORT || process.env.WEBRTC_SIGNALING_PORT || 4510);
 const PEER_STALE_MS = Number(process.env.WEBRTC_SIGNALING_PEER_STALE_MS || 120000);
 const SIGNAL_DEDUPE_WINDOW_MS = Number(process.env.WEBRTC_SIGNALING_DEDUPE_WINDOW_MS || 60000);
+const TOUCH_WRITE_INTERVAL_MS = Number(process.env.WEBRTC_SIGNALING_TOUCH_WRITE_INTERVAL_MS || 30000);
 
-/** @type {Map<string, {peers: Map<string, {last_seen_at:number}>, queues: Map<string, any[]>, signal_fingerprints: Map<string, number>}>} */
+/** @type {Map<string, {peers: Map<string, {last_seen_at:number}>, queues: Map<string, any[]>, relay_queues: Map<string, any[]>, signal_fingerprints: Map<string, number>}>} */
 const rooms = new Map();
 
 const counters = {
@@ -24,6 +25,7 @@ function getRoom(roomId) {
     rooms.set(id, {
       peers: new Map(),
       queues: new Map(),
+      relay_queues: new Map(),
       signal_fingerprints: new Map(),
     });
   }
@@ -73,6 +75,7 @@ function cleanupRoom(roomId) {
     if (peer.last_seen_at < threshold) {
       room.peers.delete(peerId);
       room.queues.delete(peerId);
+      room.relay_queues.delete(peerId);
       counters.stale_peers_cleaned_total += 1;
     }
   }
@@ -88,14 +91,21 @@ function cleanupRoom(roomId) {
 }
 
 function touchPeer(room, peerId) {
+  const ts = now();
+  const previous = room.peers.get(peerId)?.last_seen_at || 0;
+  const shouldWrite = !previous || ts - previous >= TOUCH_WRITE_INTERVAL_MS;
   if (!room.peers.has(peerId)) {
-    room.peers.set(peerId, { last_seen_at: now() });
+    room.peers.set(peerId, { last_seen_at: ts });
   } else {
-    room.peers.get(peerId).last_seen_at = now();
+    room.peers.get(peerId).last_seen_at = shouldWrite ? ts : previous;
   }
   if (!room.queues.has(peerId)) {
     room.queues.set(peerId, []);
   }
+  if (!room.relay_queues.has(peerId)) {
+    room.relay_queues.set(peerId, []);
+  }
+  return shouldWrite;
 }
 
 function isValidSignalPayload(body) {
@@ -148,7 +158,35 @@ const server = http.createServer(async (req, res) => {
     const roomId = String(url.searchParams.get('room') || 'silicaclaw-room');
     const room = getRoom(roomId);
     cleanupRoom(roomId);
-    return json(res, 200, { ok: true, peers: Array.from(room.peers.keys()) });
+    return json(res, 200, {
+      ok: true,
+      room: roomId,
+      peer_count: room.peers.size,
+      peers: Array.from(room.peers.keys()),
+      peer_details: Array.from(room.peers.entries()).map(([peerId, peer]) => ({
+        peer_id: peerId,
+        last_seen_at: peer.last_seen_at,
+        signal_queue_size: (room.queues.get(peerId) || []).length,
+        relay_queue_size: (room.relay_queues.get(peerId) || []).length,
+      })),
+    });
+  }
+
+  if (req.method === 'GET' && url.pathname === '/room') {
+    const roomId = String(url.searchParams.get('room') || 'silicaclaw-room');
+    const room = getRoom(roomId);
+    cleanupRoom(roomId);
+    return json(res, 200, {
+      ok: true,
+      room: roomId,
+      peer_count: room.peers.size,
+      peers: Array.from(room.peers.entries()).map(([peerId, peer]) => ({
+        peer_id: peerId,
+        last_seen_at: peer.last_seen_at,
+        signal_queue_size: (room.queues.get(peerId) || []).length,
+        relay_queue_size: (room.relay_queues.get(peerId) || []).length,
+      })),
+    });
   }
 
   if (req.method === 'GET' && url.pathname === '/poll') {
@@ -165,7 +203,24 @@ const server = http.createServer(async (req, res) => {
 
     const queue = room.queues.get(peerId) || [];
     room.queues.set(peerId, []);
-    return json(res, 200, { ok: true, messages: queue });
+    return json(res, 200, { ok: true, messages: queue, peers: Array.from(room.peers.keys()) });
+  }
+
+  if (req.method === 'GET' && url.pathname === '/relay/poll') {
+    const roomId = String(url.searchParams.get('room') || 'silicaclaw-room');
+    const peerId = String(url.searchParams.get('peer_id') || '');
+    if (!peerId) {
+      counters.invalid_payload_total += 1;
+      return json(res, 400, { ok: false, error: 'missing_peer_id' });
+    }
+
+    const room = getRoom(roomId);
+    touchPeer(room, peerId);
+    cleanupRoom(roomId);
+
+    const queue = room.relay_queues.get(peerId) || [];
+    room.relay_queues.set(peerId, []);
+    return json(res, 200, { ok: true, messages: queue, peers: Array.from(room.peers.keys()) });
   }
 
   if (req.method === 'POST' && url.pathname === '/join') {
@@ -193,6 +248,7 @@ const server = http.createServer(async (req, res) => {
     if (peerId) {
       room.peers.delete(peerId);
       room.queues.delete(peerId);
+      room.relay_queues.delete(peerId);
       counters.leave_total += 1;
     } else {
       counters.invalid_payload_total += 1;
@@ -240,6 +296,34 @@ const server = http.createServer(async (req, res) => {
     return json(res, 200, { ok: true });
   }
 
+  if (req.method === 'POST' && url.pathname === '/relay/publish') {
+    const body = await parseBody(req);
+    const roomId = String(body.room || 'silicaclaw-room');
+    const peerId = String(body.peer_id || '');
+    const envelope = body.envelope;
+    if (!peerId || typeof envelope !== 'object' || envelope === null) {
+      counters.invalid_payload_total += 1;
+      return json(res, 400, { ok: false, error: 'invalid_relay_payload' });
+    }
+
+    const room = getRoom(roomId);
+    touchPeer(room, peerId);
+
+    for (const targetPeerId of room.peers.keys()) {
+      if (targetPeerId === peerId) continue;
+      if (!room.relay_queues.has(targetPeerId)) room.relay_queues.set(targetPeerId, []);
+      room.relay_queues.get(targetPeerId).push({
+        id: String(body.id || randomUUID()),
+        room: roomId,
+        from_peer_id: peerId,
+        envelope,
+        at: now(),
+      });
+    }
+
+    return json(res, 200, { ok: true, delivered_to: Math.max(0, room.peers.size - 1) });
+  }
+
   return json(res, 404, { ok: false, error: 'not_found' });
 });