@silicaclaw/cli 1.0.0-beta.8 → 2026.3.18-2

package/scripts/silicaclaw-cli.mjs

@@ -1,7 +1,8 @@
 #!/usr/bin/env node
 
 import { spawnSync } from "node:child_process";
-import { existsSync, readFileSync } from "node:fs";
+import { accessSync, constants, cpSync, existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 
@@ -9,6 +10,42 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const ROOT_DIR = resolve(__dirname, "..");
 
+const COLOR = {
+  reset: "\x1b[0m",
+  bold: "\x1b[1m",
+  dim: "\x1b[2m",
+  orange: "\x1b[38;5;208m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+};
+
+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() {
+  console.log(`${paint("SilicaClaw", COLOR.bold, COLOR.orange)} ${paint(displayVersion(readVersion()), 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 run(cmd, args, extra = {}) {
   const result = spawnSync(cmd, args, {
     cwd: ROOT_DIR,
@@ -17,7 +54,10 @@ function run(cmd, args, extra = {}) {
     ...extra,
   });
   if (result.error) {
-    console.error(`[silicaclaw] failed to run ${cmd}: ${result.error.message}`);
+    headline();
+    console.log("");
+    console.error(`${paint("Command failed", COLOR.bold, COLOR.yellow)} ${cmd}`);
+    console.error(result.error.message);
     process.exit(1);
   }
   process.exit(result.status ?? 0);
@@ -37,10 +77,30 @@ function runCapture(cmd, args, extra = {}) {
   return result;
 }
 
+function runInherit(cmd, args, extra = {}) {
+  const result = spawnSync(cmd, args, {
+    cwd: ROOT_DIR,
+    stdio: "inherit",
+    env: process.env,
+    ...extra,
+  });
+  if (result.error) {
+    throw result.error;
+  }
+  return result;
+}
+
+function compactOutput(text, limit = 18) {
+  const lines = String(text || "")
+    .split(/\r?\n/)
+    .map((line) => line.trimEnd())
+    .filter(Boolean);
+  if (lines.length <= limit) return lines.join("\n");
+  return lines.slice(-limit).join("\n");
+}
+
 function readVersion() {
-  const versionFile = resolve(ROOT_DIR, "VERSION");
-  if (!existsSync(versionFile)) return "unknown";
-  return readFileSync(versionFile, "utf8").trim() || "unknown";
+  return readPackageVersion();
 }
 
 function readPackageVersion() {
@@ -54,36 +114,292 @@ function readPackageVersion() {
   }
 }
 
+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 userShimDir() {
+  return resolve(homedir(), ".silicaclaw", "bin");
+}
+
+function userShimPath() {
+  return resolve(userShimDir(), "silicaclaw");
+}
+
+function userEnvFile() {
+  return resolve(homedir(), ".silicaclaw", "env.sh");
+}
+
+function userNpmCacheDir() {
+  return resolve(homedir(), ".silicaclaw", "npm-cache");
+}
+
+function ensureLineInFile(filePath, block) {
+  try {
+    const current = existsSync(filePath) ? readFileSync(filePath, "utf8") : "";
+    if (current.includes(block.trim())) {
+      return { changed: false, error: null };
+    }
+    const next = `${current.replace(/\s*$/, "")}\n\n${block}\n`;
+    mkdirSync(dirname(filePath), { recursive: true });
+    writeFileSync(filePath, next, "utf8");
+    return { changed: true, error: null };
+  } catch (error) {
+    return { changed: false, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+function describeFileOwner(filePath) {
+  try {
+    if (!existsSync(filePath)) return null;
+    const stat = statSync(filePath);
+    return String(stat.uid);
+  } catch {
+    return null;
+  }
+}
+
+function currentUid() {
+  try {
+    return typeof process.getuid === "function" ? String(process.getuid()) : null;
+  } catch {
+    return null;
+  }
+}
+
+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"));
+  }
+
+  // Bash login shells on macOS often read .bash_profile instead of .bashrc.
+  if (
+    shell.endsWith("/bash") ||
+    process.env.BASH_VERSION ||
+    existsSync(resolve(home, ".bashrc")) ||
+    existsSync(resolve(home, ".bash_profile"))
+  ) {
+    add(resolve(home, ".bashrc"));
+    add(resolve(home, ".bash_profile"));
+  }
+
+  if (targets.length === 0) {
+    add(preferredShellRcFile());
+  }
+  return targets;
+}
+
+function installPersistentCommand() {
+  const binDir = userShimDir();
+  const shimPath = userShimPath();
+  const envFile = userEnvFile();
+  const npmCacheDir = userNpmCacheDir();
+  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(binDir, { recursive: true });
+  mkdirSync(npmCacheDir, { recursive: true });
+  writeFileSync(envFile, envBlock, { encoding: "utf8", mode: 0o755 });
+  writeFileSync(
+    shimPath,
+    [
+      "#!/usr/bin/env bash",
+      "set -euo pipefail",
+      'export npm_config_cache="${npm_config_cache:-$HOME/.silicaclaw/npm-cache}"',
+      'exec npx -y @silicaclaw/cli@beta "$@"',
+      "",
+    ].join("\n"),
+    { encoding: "utf8", mode: 0o755 }
+  );
+  const rcFiles = shellInitTargets();
+  const updatedFiles = [];
+  const configuredFiles = [];
+  const failedFiles = [];
+  for (const filePath of rcFiles) {
+    const result = ensureLineInFile(filePath, rcBlock);
+    if (result.changed) {
+      updatedFiles.push(filePath);
+      configuredFiles.push(filePath);
+    } else if (!result.error) {
+      configuredFiles.push(filePath);
+    }
+    if (result.error) {
+      failedFiles.push({ filePath, error: result.error });
+    }
+  }
+
+  headline();
+  console.log("");
+  console.log(`${paint("Installed", COLOR.bold)} \`silicaclaw\` command`);
+  kv("Command", "silicaclaw");
+  console.log("");
+  kv("Activate", `source "${envFile}"`);
+  if (configuredFiles.length > 0) {
+    kv("Startup", "configured");
+  } else {
+    kv("Startup", "manual setup required");
+  }
+  if (failedFiles.length > 0) {
+    console.log("");
+    console.log(paint("Shell files skipped", COLOR.bold, COLOR.yellow));
+    const uid = currentUid();
+    for (const item of failedFiles) {
+      const owner = describeFileOwner(item.filePath);
+      const reason =
+        owner && uid && owner !== uid
+          ? `${item.error} (owned by another user)`
+          : item.error;
+      kv(item.filePath, reason);
+    }
+    console.log("");
+    kv("Manual", '[ -f "$HOME/.silicaclaw/env.sh" ] && . "$HOME/.silicaclaw/env.sh"');
+  }
+}
+
 function isNpxRun() {
   return ROOT_DIR.includes("/.npm/_npx/");
 }
 
+function canWriteGlobalPrefix() {
+  try {
+    const prefixResult = runCapture("npm", ["prefix", "-g"]);
+    if ((prefixResult.status ?? 1) !== 0) return false;
+    const prefix = String(prefixResult.stdout || "").trim();
+    if (!prefix) return false;
+    const targetDir = resolve(prefix, "lib", "node_modules");
+    accessSync(targetDir, constants.W_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 function showUpdateGuide(current, latest, beta) {
-  console.log("SilicaClaw update check");
-  console.log(`current: ${current}`);
-  console.log(`latest : ${latest || "-"}`);
-  console.log(`beta   : ${beta || "-"}`);
+  headline();
   console.log("");
-
   const upToDate = Boolean(beta) && current === beta;
   if (upToDate) {
-    console.log("You are already on the latest beta.");
+    kv("Status", `up to date (${current})`);
   } else {
-    console.log("Update available.");
+    kv("Status", `beta update available (${beta || "-"})`);
   }
   console.log("");
-  console.log("Recommended commands:");
-  console.log("1) npx mode (no global install)");
-  console.log("   npx @silicaclaw/cli@beta onboard");
-  console.log("   npx @silicaclaw/cli@beta connect");
-  console.log("");
-  console.log("2) global install mode");
-  console.log("   npm i -g @silicaclaw/cli@beta");
-  console.log("   silicaclaw version");
-  console.log("");
-  if (isNpxRun()) {
-    console.log("Detected npx runtime: use npx commands above for immediate update.");
+  kv("Start", "silicaclaw start");
+  kv("Status", "silicaclaw status");
+}
+
+function getGatewayStatus() {
+  try {
+    const result = runCapture("node", [resolve(ROOT_DIR, "scripts", "silicaclaw-gateway.mjs"), "status", "--json"], {
+      cwd: process.cwd(),
+    });
+    if ((result.status ?? 1) !== 0) return null;
+    const text = String(result.stdout || "").trim();
+    return text ? JSON.parse(text) : null;
+  } catch {
+    return null;
+  }
+}
+
+function isManagedAppDir(appDir) {
+  if (!appDir || !existsSync(resolve(appDir, "package.json"))) return false;
+  try {
+    const pkg = JSON.parse(readFileSync(resolve(appDir, "package.json"), "utf8"));
+    const name = String(pkg?.name || "");
+    return name === "@silicaclaw/cli" || name === "silicaclaw";
+  } catch {
+    return false;
+  }
+}
+
+function syncCurrentPackageToAppDir(appDir) {
+  if (!appDir || resolve(appDir) === ROOT_DIR) return false;
+  if (!isManagedAppDir(appDir)) return false;
+
+  const entries = [
+    "apps/local-console",
+    "apps/public-explorer",
+    "packages/core",
+    "packages/network",
+    "packages/storage",
+    "scripts",
+    "README.md",
+    "INSTALL.md",
+    "CHANGELOG.md",
+    "ARCHITECTURE.md",
+    "ROADMAP.md",
+    "SOCIAL_MD_SPEC.md",
+    "DEMO_GUIDE.md",
+    "RELEASE_NOTES_v1.0.md",
+    "social.md.example",
+    "openclaw.social.md.example",
+    "VERSION",
+    "package.json",
+    "package-lock.json",
+  ];
+
+  for (const rel of entries) {
+    const src = resolve(ROOT_DIR, rel);
+    if (!existsSync(src)) continue;
+    const dst = resolve(appDir, rel);
+    cpSync(src, dst, { recursive: true, force: true });
+  }
+  return true;
+}
+
+function restartGatewayIfRunning() {
+  const status = getGatewayStatus();
+  const appDir = status?.app_dir ? String(status.app_dir) : "";
+  syncCurrentPackageToAppDir(appDir);
+
+  const localRunning = Boolean(status?.local_console?.running);
+  const signalingRunning = Boolean(status?.signaling?.running);
+  if (!localRunning && !signalingRunning) {
+    return;
   }
+
+  const mode = String(status?.mode || "local");
+  const args = [resolve(ROOT_DIR, "scripts", "silicaclaw-gateway.mjs"), "restart", `--mode=${mode}`];
+  if (mode === "global-preview" && status?.signaling?.url) {
+    args.push(`--signaling-url=${status.signaling.url}`);
+  }
+  if (mode === "global-preview" && status?.signaling?.room) {
+    args.push(`--room=${status.signaling.room}`);
+  }
+
+  console.log("");
+  console.log(paint("Refreshing services", COLOR.bold));
+  runInherit("node", args, { cwd: process.cwd() });
+}
+
+function tryGlobalUpgrade(beta) {
+  const writableGlobal = canWriteGlobalPrefix();
+  if (!writableGlobal) return false;
+  kv("Upgrade", `installing @silicaclaw/cli@${beta} globally`);
+  const result = runInherit("npm", ["i", "-g", `@silicaclaw/cli@${beta}`]);
+  return (result.status ?? 1) === 0;
 }
 
 function update() {
@@ -91,8 +407,12 @@ function update() {
   try {
     const result = runCapture("npm", ["view", "@silicaclaw/cli", "dist-tags", "--json"]);
     if ((result.status ?? 1) !== 0) {
-      console.error("Failed to query npm dist-tags.");
+      headline();
+      console.log("");
+      console.error(paint("Update check failed", COLOR.bold, COLOR.yellow));
       if (result.stderr) console.error(result.stderr.trim());
+      console.log("");
+      kv("Try", "npm view @silicaclaw/cli dist-tags --json");
       process.exit(result.status ?? 1);
     }
     const text = String(result.stdout || "").trim();
@@ -100,43 +420,73 @@ function update() {
     const latest = tags.latest ? String(tags.latest) : "";
     const beta = tags.beta ? String(tags.beta) : "";
     showUpdateGuide(current, latest, beta);
+    const hasNewBeta = Boolean(beta) && beta !== current;
+    const npxRuntime = isNpxRun();
+
+    if (hasNewBeta) {
+      if (npxRuntime) {
+        kv("Update", `next run will use ${beta}`);
+      } else if (tryGlobalUpgrade(beta)) {
+        kv("Update", `installed ${beta}`);
+      } else {
+        kv("Update", `install ${beta} manually if needed`);
+      }
+    }
+
+    restartGatewayIfRunning();
     process.exit(0);
   } catch (error) {
-    console.error(`Update check failed: ${error.message}`);
-    console.log("Try manually:");
-    console.log("npm view @silicaclaw/cli dist-tags --json");
+    headline();
+    console.log("");
+    console.error(paint("Update check failed", COLOR.bold, COLOR.yellow));
+    console.error(error.message);
+    console.log("");
+    kv("Try", "npm view @silicaclaw/cli dist-tags --json");
     process.exit(1);
   }
 }
 
+function doctor() {
+  const steps = [
+    { label: "Check", cmd: "npm", args: ["run", "-ws", "check"] },
+    { label: "Build", cmd: "npm", args: ["run", "-ws", "build"] },
+    { label: "Functional", cmd: "node", args: ["scripts/functional-check.mjs"] },
+  ];
+
+  headline();
+  console.log("");
+
+  for (const step of steps) {
+    const result = runCapture(step.cmd, step.args, { cwd: ROOT_DIR });
+    if ((result.status ?? 1) === 0) {
+      kv(step.label, paint("ok", COLOR.green));
+      continue;
+    }
+
+    kv(step.label, paint("failed", COLOR.yellow));
+    const detail = compactOutput(`${result.stdout || ""}\n${result.stderr || ""}`);
+    if (detail) {
+      console.log("");
+      console.log(detail);
+    }
+    process.exit(result.status ?? 1);
+  }
+}
+
 function help() {
-  console.log(`
-SilicaClaw CLI
-
-Usage:
-  silicaclaw onboard
-  silicaclaw connect
-  silicaclaw update
-  silicaclaw gateway <start|stop|restart|status|logs>
-  silicaclaw local-console
-  silicaclaw explorer
-  silicaclaw signaling
-  silicaclaw doctor
-  silicaclaw version
-  silicaclaw help
-
-Commands:
-  onboard        Interactive step-by-step onboarding (recommended)
-  connect        Cross-network connect wizard (global-preview first)
-  update         Check latest npm version and show upgrade commands
-  gateway        Manage background services (start/stop/restart/status/logs)
-  local-console  Start local console (http://localhost:4310)
-  explorer       Start public explorer (http://localhost:4311)
-  signaling      Start WebRTC signaling preview server
-  doctor         Run project checks (npm run health)
-  version        Print SilicaClaw version
-  help           Show this help
-`.trim());
+  headline();
+  console.log("");
+  section("Commands");
+  kv("Install", "npx -y @silicaclaw/cli@beta install");
+  kv("Start", "silicaclaw start");
+  kv("Status", "silicaclaw status");
+  kv("Stop", "silicaclaw stop");
+  kv("Update", "silicaclaw update");
+  kv("Onboard", "silicaclaw onboard");
+  kv("Connect", "silicaclaw connect");
+  kv("Logs", "silicaclaw logs local-console");
+  kv("Doctor", "silicaclaw doctor");
+  kv("Help", "silicaclaw help");
 }
 
 const cmd = String(process.argv[2] || "help").trim().toLowerCase();
@@ -157,11 +507,23 @@ switch (cmd) {
   case "update":
     update();
     break;
+  case "install":
+    installPersistentCommand();
+    break;
   case "gateway":
     run("node", [resolve(ROOT_DIR, "scripts", "silicaclaw-gateway.mjs"), ...process.argv.slice(3)], {
       cwd: process.cwd(),
     });
     break;
+  case "start":
+  case "stop":
+  case "restart":
+  case "status":
+  case "logs":
+    run("node", [resolve(ROOT_DIR, "scripts", "silicaclaw-gateway.mjs"), cmd, ...process.argv.slice(3)], {
+      cwd: process.cwd(),
+    });
+    break;
   case "local-console":
   case "console":
     run("npm", ["run", "local-console"]);
@@ -175,12 +537,12 @@ switch (cmd) {
     run("npm", ["run", "webrtc-signaling"]);
     break;
   case "doctor":
-    run("npm", ["run", "health"]);
+    doctor();
     break;
   case "version":
   case "-v":
   case "--version":
-    console.log(readVersion());
+    headline();
     break;
   case "help":
   case "-h":