@silicaclaw/cli 2026.3.19-2 → 2026.3.19-21

package/scripts/silicaclaw-gateway.mjs

@@ -1,14 +1,20 @@
 #!/usr/bin/env node
 
 import { spawn, spawnSync } from "node:child_process";
-import { existsSync, mkdirSync, openSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { cpSync, existsSync, mkdirSync, openSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
+import defaults from "../config/silicaclaw-defaults.json" with { type: "json" };
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const ROOT_DIR = resolve(__dirname, "..");
+const LOCAL_CONSOLE_PORT = defaults.ports.local_console;
+const DEFAULT_NETWORK_MODE = defaults.network.default_mode;
+const DEFAULT_SIGNALING_URL = defaults.network.global_preview.relay_url;
+const DEFAULT_ROOM = defaults.network.global_preview.room;
+const LOCAL_CONSOLE_BASE_URL = defaults.bridge.api_base;
 
 const argv = process.argv.slice(2);
 const cmd = String(argv[0] || "help").toLowerCase();
@@ -48,7 +54,7 @@ function headline() {
       version = "unknown";
     }
   }
-  console.log(`${paint("SilicaClaw", COLOR.bold, COLOR.orange)} ${paint(displayVersion(version), COLOR.dim)}`);
+  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));
 }
 
@@ -102,6 +108,10 @@ function detectAppDir() {
     return resolve(cwd);
   }
 
+  if (isSilicaClawDir(ROOT_DIR)) {
+    return resolve(ROOT_DIR);
+  }
+
   const homeCandidate = join(homedir(), "silicaclaw");
   if (isSilicaClawDir(homeCandidate)) {
     return resolve(homeCandidate);
@@ -110,9 +120,17 @@ function detectAppDir() {
   return ROOT_DIR;
 }
 
+function detectWorkspaceDir() {
+  const envDir = process.env.SILICACLAW_WORKSPACE_DIR;
+  if (envDir) return resolve(envDir);
+  return resolve(process.cwd());
+}
+
 const APP_DIR = detectAppDir();
+const WORKSPACE_DIR = detectWorkspaceDir();
 const LOCAL_CONSOLE_DIR = join(APP_DIR, "apps", "local-console");
-const STATE_DIR = join(APP_DIR, ".silicaclaw", "gateway");
+const STATE_DIR = join(homedir(), ".silicaclaw", "gateway");
+const MANAGED_RUNTIME_DIR = join(homedir(), ".silicaclaw", "runtime", "silicaclaw");
 const CONSOLE_PID_FILE = join(STATE_DIR, "local-console.pid");
 const CONSOLE_LOG_FILE = join(STATE_DIR, "local-console.log");
 const SIGNALING_PID_FILE = join(STATE_DIR, "signaling.pid");
@@ -130,6 +148,10 @@ function ensureLaunchAgentsDir() {
   mkdirSync(LAUNCH_AGENTS_DIR, { recursive: true });
 }
 
+function ensureManagedRuntimeDir() {
+  mkdirSync(MANAGED_RUNTIME_DIR, { recursive: true });
+}
+
 function readPid(file) {
   if (!existsSync(file)) return null;
   const text = String(readFileSync(file, "utf8")).trim();
@@ -151,6 +173,46 @@ function removeFileIfExists(path) {
   if (existsSync(path)) rmSync(path, { force: true });
 }
 
+function syncManagedRuntime() {
+  if (resolve(APP_DIR) === resolve(MANAGED_RUNTIME_DIR)) return MANAGED_RUNTIME_DIR;
+
+  ensureManagedRuntimeDir();
+  const entries = [
+    "config",
+    "dist",
+    "scripts",
+    "apps/local-console/public",
+    "apps/public-explorer/public",
+    "package.json",
+    "package-lock.json",
+    "VERSION",
+    "node_modules",
+  ];
+
+  for (const rel of entries) {
+    const src = resolve(APP_DIR, rel);
+    if (!existsSync(src)) continue;
+    const dst = resolve(MANAGED_RUNTIME_DIR, rel);
+    rmSync(dst, { recursive: true, force: true });
+    cpSync(src, dst, {
+      recursive: true,
+      force: true,
+      dereference: rel === "node_modules",
+    });
+  }
+
+  const manifest = {
+    source_app_dir: APP_DIR,
+    synced_at: Date.now(),
+    version: readJson(resolve(APP_DIR, "package.json"))?.version || null,
+    dist_server_mtime: existsSync(resolve(APP_DIR, "dist", "apps", "local-console", "src", "server.js"))
+      ? statSync(resolve(APP_DIR, "dist", "apps", "local-console", "src", "server.js")).mtimeMs
+      : null,
+  };
+  writeFileSync(resolve(MANAGED_RUNTIME_DIR, ".silicaclaw-runtime.json"), JSON.stringify(manifest, null, 2));
+  return MANAGED_RUNTIME_DIR;
+}
+
 async function stopPid(pid, name) {
   if (!pid || !isRunning(pid)) return;
   try {
@@ -239,25 +301,34 @@ function runLaunchctl(args) {
   });
 }
 
-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 launchServiceTarget(label) {
+  return `${launchdDomain()}/${label}`;
+}
+
+function isLaunchctlNotLoadedResult(result) {
+  const text = `${result?.stdout || ""}\n${result?.stderr || ""}`.toLowerCase();
+  return (
+    text.includes("could not find service") ||
+    text.includes("service not found") ||
+    text.includes("bad request") ||
+    text.includes("not loaded")
+  );
+}
+
+function localConsoleProgramArguments(appDir = APP_DIR) {
+  return [
+    process.execPath,
+    resolve(appDir, "dist", "apps", "local-console", "src", "server.js"),
+  ];
 }
 
 function isLaunchAgentLoaded(label) {
-  const result = runLaunchctl(["print", `${launchdDomain()}/${label}`]);
+  const result = runLaunchctl(["print", launchServiceTarget(label)]);
   return (result.status ?? 1) === 0;
 }
 
 function readLaunchAgentRuntime(label) {
-  const result = runLaunchctl(["print", `${launchdDomain()}/${label}`]);
+  const result = runLaunchctl(["print", launchServiceTarget(label)]);
   if ((result.status ?? 1) !== 0) return { loaded: false, pid: null };
   const text = `${result.stdout || ""}\n${result.stderr || ""}`;
   const pidMatch = text.match(/pid = (\d+)/);
@@ -267,7 +338,47 @@ function readLaunchAgentRuntime(label) {
   };
 }
 
-function installLaunchAgent({ label, programArguments, workingDirectory, logFile, environment }) {
+function writeLaunchAgentPlistIfChanged(plistPath, plist) {
+  const current = existsSync(plistPath) ? String(readFileSync(plistPath, "utf8")) : null;
+  if (current === plist) return false;
+  writeFileSync(plistPath, plist, "utf8");
+  return true;
+}
+
+function bootstrapLaunchAgent(label, 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 startLaunchAgent(label, plistPath) {
+  const result = runLaunchctl(["start", launchServiceTarget(label)]);
+  if ((result.status ?? 1) === 0) return;
+  if (!isLaunchctlNotLoadedResult(result)) {
+    const detail = String(result.stderr || result.stdout || "launchctl start failed").trim();
+    throw new Error(detail);
+  }
+  bootstrapLaunchAgent(label, plistPath);
+}
+
+function restartLaunchAgent(label, plistPath) {
+  const result = runLaunchctl(["kickstart", "-k", launchServiceTarget(label)]);
+  if ((result.status ?? 1) === 0) return;
+  if (!isLaunchctlNotLoadedResult(result)) {
+    const detail = String(result.stderr || result.stdout || "launchctl kickstart failed").trim();
+    throw new Error(detail);
+  }
+  bootstrapLaunchAgent(label, plistPath);
+  const retry = runLaunchctl(["kickstart", "-k", launchServiceTarget(label)]);
+  if ((retry.status ?? 1) !== 0) {
+    const detail = String(retry.stderr || retry.stdout || "launchctl kickstart failed").trim();
+    throw new Error(detail);
+  }
+}
+
+function ensureLaunchAgent({ label, programArguments, workingDirectory, logFile, environment }) {
   ensureLaunchAgentsDir();
   ensureStateDir();
   const plistPath = launchAgentPlistPath(label);
@@ -279,17 +390,23 @@ function installLaunchAgent({ label, programArguments, workingDirectory, logFile
     stderrPath: logFile,
     environment,
   });
-  writeFileSync(plistPath, plist, "utf8");
-
-  if (isLaunchAgentLoaded(label)) {
-    runLaunchctl(["bootout", launchdDomain(), plistPath]);
+  const changed = writeLaunchAgentPlistIfChanged(plistPath, plist);
+  const loaded = isLaunchAgentLoaded(label);
+
+  if (changed && loaded) {
+    const bootout = runLaunchctl(["bootout", launchdDomain(), plistPath]);
+    if ((bootout.status ?? 1) !== 0 && !isLaunchctlNotLoadedResult(bootout)) {
+      const detail = String(bootout.stderr || bootout.stdout || "launchctl bootout failed").trim();
+      throw new Error(detail);
+    }
+    bootstrapLaunchAgent(label, plistPath);
+    return { changed: true, loaded: true, 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);
+  if (!loaded) {
+    bootstrapLaunchAgent(label, plistPath);
   }
+  return { changed, loaded, plistPath };
 }
 
 function stopLaunchAgent(label) {
@@ -353,10 +470,11 @@ function launchdStatusPayload() {
   const state = readState();
   const localRuntime = readLaunchAgentRuntime(LOCAL_CONSOLE_LABEL);
   const signalingRuntime = readLaunchAgentRuntime(SIGNALING_LABEL);
-  const localListener = listeningProcessOnPort(4310);
+  const localListener = listeningProcessOnPort(LOCAL_CONSOLE_PORT);
   const signalingListener = listeningProcessOnPort(4510);
   return {
     app_dir: APP_DIR,
+    workspace_dir: WORKSPACE_DIR,
     mode: state?.mode || "unknown",
     adapter: state?.adapter || "unknown",
     service_manager: "launchd",
@@ -387,10 +505,12 @@ function buildStatusPayload() {
   const localPid = readPid(CONSOLE_PID_FILE);
   const sigPid = readPid(SIGNALING_PID_FILE);
   const state = readState();
-  const localListener = listeningProcessOnPort(4310);
+  const localListener = listeningProcessOnPort(LOCAL_CONSOLE_PORT);
   const signalingListener = listeningProcessOnPort(4510);
   return {
     app_dir: APP_DIR,
+    managed_app_dir: state?.managed_app_dir || null,
+    workspace_dir: state?.workspace_dir || WORKSPACE_DIR,
     mode: state?.mode || "unknown",
     adapter: state?.adapter || "unknown",
     local_console: {
@@ -424,10 +544,10 @@ function showStatusHuman() {
       : `${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");
+    kv("Relay", payload.signaling.url || DEFAULT_SIGNALING_URL);
+    kv("Room", payload.signaling.room || DEFAULT_ROOM);
   }
-  if (payload.local_console.running) kv("Open", "http://localhost:4310");
+  if (payload.local_console.running) kv("Open", LOCAL_CONSOLE_BASE_URL);
   return payload;
 }
 
@@ -436,10 +556,10 @@ function printConnectionSummary(status, verb = "Started") {
   headline();
   console.log("");
   kv("Status", `${verb.toLowerCase()} · ${status.mode}`);
-  kv("Console", `http://localhost:4310`);
+  kv("Console", LOCAL_CONSOLE_BASE_URL);
   if (status.mode === "global-preview") {
-    const signalingUrl = status?.signaling?.url || "https://relay.silicaclaw.com";
-    const room = status?.signaling?.room || "silicaclaw-global-preview";
+    const signalingUrl = status?.signaling?.url || DEFAULT_SIGNALING_URL;
+    const room = status?.signaling?.room || DEFAULT_ROOM;
     kv("Relay", signalingUrl);
     kv("Room", room);
   }
@@ -472,6 +592,22 @@ function normalizePathForMatch(value) {
   return String(value || "").replace(/\\/g, "/");
 }
 
+function isLocalConsoleCommand(command) {
+  const text = normalizePathForMatch(command).toLowerCase();
+  return (
+    text.includes("@silicaclaw/local-console") ||
+    text.includes("npm run --workspace @silicaclaw/local-console start") ||
+    text.includes("/apps/local-console/") ||
+    text.includes("dist/apps/local-console/src/server.js") ||
+    text.includes("src/server.ts")
+  );
+}
+
+function isSignalingCommand(command) {
+  const text = normalizePathForMatch(command).toLowerCase();
+  return text.includes("webrtc-signaling-server.mjs") || text.includes("npm run webrtc-signaling");
+}
+
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -486,6 +622,28 @@ async function waitForPort(port, timeoutMs = 5000) {
   return null;
 }
 
+async function waitForCurrentAppListener(port, kind, timeoutMs = 5000) {
+  const startedAt = Date.now();
+  let lastListener = null;
+  while (Date.now() - startedAt < timeoutMs) {
+    const listener = listeningProcessOnPort(port);
+    lastListener = listener;
+    if (listener && isCurrentAppListener(listener, kind)) return listener;
+    await sleep(200);
+  }
+  return lastListener;
+}
+
+async function waitForPortToClear(port, timeoutMs = 5000) {
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < timeoutMs) {
+    const listener = listeningProcessOnPort(port);
+    if (!listener) return true;
+    await sleep(200);
+  }
+  return false;
+}
+
 function tailText(file, lines = 20) {
   if (!existsSync(file)) return "";
   const text = String(readFileSync(file, "utf8"));
@@ -494,21 +652,24 @@ function tailText(file, lines = 20) {
 
 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;
+  const command = listener.command;
   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")
-    );
+    return isLocalConsoleCommand(command);
+  }
+  if (kind === "signaling") {
+    return isSignalingCommand(command);
+  }
+  return false;
+}
+
+function isCurrentAppListener(listener, kind) {
+  if (!listener?.command) return false;
+  const command = listener.command;
+  if (kind === "local-console") {
+    return isLocalConsoleCommand(command);
   }
   if (kind === "signaling") {
-    return command.includes("webrtc-signaling-server.mjs") || command.includes("npm run webrtc-signaling");
+    return isSignalingCommand(command);
   }
   return false;
 }
@@ -528,8 +689,26 @@ async function stopOwnedListener(port, kind) {
   return true;
 }
 
+async function drainOwnedListener(port, kind, timeoutMs = 5000) {
+  const startedAt = Date.now();
+  let attempted = false;
+  while (Date.now() - startedAt < timeoutMs) {
+    const listener = listeningProcessOnPort(port);
+    if (!listener) return { cleared: true, attempted };
+    if (!isOwnedListener(listener, kind)) {
+      return { cleared: false, attempted };
+    }
+    attempted = true;
+    await stopOwnedListener(port, kind);
+    const cleared = await waitForPortToClear(port, 1200);
+    if (cleared) return { cleared: true, attempted };
+  }
+  const finalListener = listeningProcessOnPort(port);
+  return { cleared: !finalListener, attempted };
+}
+
 function printStopSummary() {
-  const localListener = listeningProcessOnPort(4310);
+  const localListener = listeningProcessOnPort(LOCAL_CONSOLE_PORT);
   const signalingListener = listeningProcessOnPort(4510);
   headline();
   console.log("");
@@ -538,7 +717,10 @@ function printStopSummary() {
     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");
+    if (isOwnedListener(localListener, "local-console")) {
+      kv("Hint", `an older SilicaClaw local-console process is still holding port ${LOCAL_CONSOLE_PORT}`);
+    }
+    kv("Inspect", `lsof -nP -iTCP:${LOCAL_CONSOLE_PORT} -sTCP:LISTEN`);
     kv("Stop pid", `kill ${localListener.pid}`);
   }
   if (!signalingListener) {
@@ -570,8 +752,8 @@ async function stopAll() {
   if (isLaunchdPlatform()) {
     stopLaunchAgent(LOCAL_CONSOLE_LABEL);
     stopLaunchAgent(SIGNALING_LABEL);
-    await stopOwnedListener(4310, "local-console");
-    await stopOwnedListener(4510, "signaling");
+    await drainOwnedListener(LOCAL_CONSOLE_PORT, "local-console", 8000);
+    await drainOwnedListener(4510, "signaling", 5000);
     removeFileIfExists(CONSOLE_PID_FILE);
     removeFileIfExists(SIGNALING_PID_FILE);
     writeState({
@@ -584,8 +766,8 @@ 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");
+  await drainOwnedListener(LOCAL_CONSOLE_PORT, "local-console", 5000);
+  await drainOwnedListener(4510, "signaling", 5000);
   removeFileIfExists(CONSOLE_PID_FILE);
   removeFileIfExists(SIGNALING_PID_FILE);
   writeState({
@@ -597,38 +779,12 @@ async function stopAll() {
 async function startAll() {
   ensureStateDir();
 
-  const mode = parseMode(parseFlag("mode", process.env.NETWORK_MODE || "global-preview"));
+  const mode = parseMode(parseFlag("mode", process.env.NETWORK_MODE || DEFAULT_NETWORK_MODE));
   const adapter = adapterForMode(mode);
-  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 signalingUrl = parseFlag("signaling-url", process.env.WEBRTC_SIGNALING_URL || DEFAULT_SIGNALING_URL);
+  const room = parseFlag("room", process.env.WEBRTC_ROOM || DEFAULT_ROOM);
   const shouldDisableSignaling = hasFlag("no-signaling");
 
-  const currentLocalPid = readPid(CONSOLE_PID_FILE);
-  const currentSigPid = readPid(SIGNALING_PID_FILE);
-  const currentListener = listeningProcessOnPort(4310);
-  if (currentListener && isOwnedListener(currentListener, "local-console") && !isRunning(currentLocalPid)) {
-    writeFileSync(CONSOLE_PID_FILE, String(currentListener.pid));
-  }
-
-  let localPid = readPid(CONSOLE_PID_FILE);
-  if (!isRunning(localPid)) {
-    removeFileIfExists(CONSOLE_PID_FILE);
-    const env = {
-      NETWORK_ADAPTER: adapter,
-      NETWORK_MODE: mode,
-      WEBRTC_SIGNALING_URL: signalingUrl,
-      WEBRTC_ROOM: room,
-    };
-    localPid = spawnBackground(
-      process.execPath,
-      ["--import", "tsx", "src/server.ts"],
-      env,
-      CONSOLE_LOG_FILE,
-      CONSOLE_PID_FILE,
-      LOCAL_CONSOLE_DIR,
-    );
-  }
-
   const { host, port } = parseUrlHostPort(signalingUrl);
   const shouldAutoStartSignaling =
     mode === "global-preview" &&
@@ -636,32 +792,34 @@ async function startAll() {
     (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 managedAppDir = syncManagedRuntime();
+    const signalingEntry = resolve(managedAppDir, "scripts", "webrtc-signaling-server.mjs");
+    await drainOwnedListener(LOCAL_CONSOLE_PORT, "local-console", 8000);
+    await drainOwnedListener(4510, "signaling", 5000);
     const baseEnv = {
       NETWORK_ADAPTER: adapter,
       NETWORK_MODE: mode,
       WEBRTC_SIGNALING_URL: signalingUrl,
       WEBRTC_ROOM: room,
+      SILICACLAW_APP_DIR: managedAppDir,
+      SILICACLAW_WORKSPACE_DIR: WORKSPACE_DIR,
       PATH: process.env.PATH || "/usr/bin:/bin:/usr/sbin:/sbin",
       HOME: process.env.HOME || homedir(),
     };
 
-    installLaunchAgent({
+    ensureLaunchAgent({
       label: LOCAL_CONSOLE_LABEL,
-      programArguments: [npmPath, "run", "--workspace", "@silicaclaw/local-console", "start"],
-      workingDirectory: APP_DIR,
+      programArguments: localConsoleProgramArguments(managedAppDir),
+      workingDirectory: managedAppDir,
       logFile: CONSOLE_LOG_FILE,
       environment: baseEnv,
     });
 
     if (shouldAutoStartSignaling) {
-      installLaunchAgent({
+      ensureLaunchAgent({
         label: SIGNALING_LABEL,
         programArguments: [process.execPath, signalingEntry],
-        workingDirectory: APP_DIR,
+        workingDirectory: managedAppDir,
         logFile: SIGNALING_LOG_FILE,
         environment: {
           PATH: baseEnv.PATH,
@@ -675,6 +833,8 @@ async function startAll() {
 
     writeState({
       app_dir: APP_DIR,
+      managed_app_dir: managedAppDir,
+      workspace_dir: WORKSPACE_DIR,
       mode,
       adapter,
       signaling_url: signalingUrl,
@@ -684,6 +844,38 @@ async function startAll() {
     return { localPid: null, signalingPid: null };
   }
 
+  const currentLocalPid = readPid(CONSOLE_PID_FILE);
+  const currentSigPid = readPid(SIGNALING_PID_FILE);
+  const currentListener = listeningProcessOnPort(LOCAL_CONSOLE_PORT);
+  if (currentListener && isOwnedListener(currentListener, "local-console") && !isRunning(currentLocalPid)) {
+    writeFileSync(CONSOLE_PID_FILE, String(currentListener.pid));
+  }
+
+  let localPid = readPid(CONSOLE_PID_FILE);
+  if (!isRunning(localPid)) {
+    removeFileIfExists(CONSOLE_PID_FILE);
+    await drainOwnedListener(LOCAL_CONSOLE_PORT, "local-console", 8000);
+    const remainingLocalListener = listeningProcessOnPort(LOCAL_CONSOLE_PORT);
+    if (remainingLocalListener) {
+      throw new Error(`port ${LOCAL_CONSOLE_PORT} is occupied by pid=${remainingLocalListener.pid}`);
+    }
+    const env = {
+      NETWORK_ADAPTER: adapter,
+      NETWORK_MODE: mode,
+      WEBRTC_SIGNALING_URL: signalingUrl,
+      WEBRTC_ROOM: room,
+      SILICACLAW_WORKSPACE_DIR: WORKSPACE_DIR,
+    };
+    localPid = spawnBackground(
+      process.execPath,
+      ["dist/apps/local-console/src/server.js"],
+      env,
+      CONSOLE_LOG_FILE,
+      CONSOLE_PID_FILE,
+      LOCAL_CONSOLE_DIR,
+    );
+  }
+
   let signalingPid = currentSigPid;
   if (shouldAutoStartSignaling) {
     if (!isRunning(currentSigPid)) {
@@ -700,6 +892,7 @@ async function startAll() {
 
   writeState({
     app_dir: APP_DIR,
+    workspace_dir: WORKSPACE_DIR,
     mode,
     adapter,
     signaling_url: signalingUrl,
@@ -709,6 +902,81 @@ async function startAll() {
   return { localPid, signalingPid: shouldAutoStartSignaling ? signalingPid : null };
 }
 
+async function restartAll() {
+  if (!isLaunchdPlatform()) {
+    await stopAll();
+    await startAll();
+    return;
+  }
+
+  ensureStateDir();
+
+  const mode = parseMode(parseFlag("mode", process.env.NETWORK_MODE || DEFAULT_NETWORK_MODE));
+  const adapter = adapterForMode(mode);
+  const signalingUrl = parseFlag("signaling-url", process.env.WEBRTC_SIGNALING_URL || DEFAULT_SIGNALING_URL);
+  const room = parseFlag("room", process.env.WEBRTC_ROOM || DEFAULT_ROOM);
+  const shouldDisableSignaling = hasFlag("no-signaling");
+  const { host, port } = parseUrlHostPort(signalingUrl);
+  const shouldAutoStartSignaling =
+    mode === "global-preview" &&
+    !shouldDisableSignaling &&
+    (host === "localhost" || host === "127.0.0.1");
+
+  const managedAppDir = syncManagedRuntime();
+  const signalingEntry = resolve(managedAppDir, "scripts", "webrtc-signaling-server.mjs");
+  const baseEnv = {
+    NETWORK_ADAPTER: adapter,
+    NETWORK_MODE: mode,
+    WEBRTC_SIGNALING_URL: signalingUrl,
+    WEBRTC_ROOM: room,
+    SILICACLAW_APP_DIR: managedAppDir,
+    SILICACLAW_WORKSPACE_DIR: WORKSPACE_DIR,
+    PATH: process.env.PATH || "/usr/bin:/bin:/usr/sbin:/sbin",
+    HOME: process.env.HOME || homedir(),
+  };
+
+  const localConsoleService = ensureLaunchAgent({
+    label: LOCAL_CONSOLE_LABEL,
+    programArguments: localConsoleProgramArguments(managedAppDir),
+    workingDirectory: managedAppDir,
+    logFile: CONSOLE_LOG_FILE,
+    environment: baseEnv,
+  });
+  if (!localConsoleService.changed) {
+    restartLaunchAgent(LOCAL_CONSOLE_LABEL, localConsoleService.plistPath);
+  }
+
+  if (shouldAutoStartSignaling) {
+    const signalingService = ensureLaunchAgent({
+      label: SIGNALING_LABEL,
+      programArguments: [process.execPath, signalingEntry],
+      workingDirectory: managedAppDir,
+      logFile: SIGNALING_LOG_FILE,
+      environment: {
+        PATH: baseEnv.PATH,
+        HOME: baseEnv.HOME,
+        PORT: String(port),
+      },
+    });
+    if (!signalingService.changed) {
+      restartLaunchAgent(SIGNALING_LABEL, signalingService.plistPath);
+    }
+  } else {
+    uninstallLaunchAgent(SIGNALING_LABEL);
+  }
+
+  writeState({
+    app_dir: APP_DIR,
+    managed_app_dir: managedAppDir,
+    workspace_dir: WORKSPACE_DIR,
+    mode,
+    adapter,
+    signaling_url: signalingUrl,
+    room,
+    updated_at: Date.now(),
+  });
+}
+
 async function main() {
   if (cmd === "help" || cmd === "-h" || cmd === "--help") {
     printHelp();
@@ -724,11 +992,15 @@ async function main() {
   }
   if (cmd === "start") {
     await startAll();
-    const listener = await waitForPort(4310, 15000);
-    if (!listener) {
+    const listener = await waitForCurrentAppListener(LOCAL_CONSOLE_PORT, "local-console", 15000);
+    if (!listener || !isCurrentAppListener(listener, "local-console")) {
       headline();
       console.log("");
       kv("Status", paint("failed to start", COLOR.red));
+      if (listener) {
+        kv("Conflict", `port ${LOCAL_CONSOLE_PORT} is occupied by pid=${listener.pid}`);
+        kv("Inspect", `lsof -nP -iTCP:${LOCAL_CONSOLE_PORT} -sTCP:LISTEN`);
+      }
       const recent = tailText(CONSOLE_LOG_FILE, 18);
       if (recent) {
         console.log("");
@@ -747,13 +1019,16 @@ async function main() {
     return;
   }
   if (cmd === "restart") {
-    await stopAll();
-    await startAll();
-    const listener = await waitForPort(4310, 15000);
-    if (!listener) {
+    await restartAll();
+    const listener = await waitForCurrentAppListener(LOCAL_CONSOLE_PORT, "local-console", 15000);
+    if (!listener || !isCurrentAppListener(listener, "local-console")) {
       headline();
       console.log("");
       kv("Status", paint("failed to restart", COLOR.red));
+      if (listener) {
+        kv("Conflict", `port ${LOCAL_CONSOLE_PORT} is occupied by pid=${listener.pid}`);
+        kv("Inspect", `lsof -nP -iTCP:${LOCAL_CONSOLE_PORT} -sTCP:LISTEN`);
+      }
       const recent = tailText(CONSOLE_LOG_FILE, 18);
       if (recent) {
         console.log("");