create-openclaw-bot 5.15.1 → 5.15.4

package/dist/server/local-server.js

@@ -1,5 +1,5 @@
 import http from 'http';
-import fs, { createReadStream, existsSync, promises as fsp } from 'fs';
+import fs, { createReadStream, existsSync, readFileSync, promises as fsp } from 'fs';
 import { createRequire } from 'module';
 import { basename, dirname, extname, join, normalize, resolve } from 'path';
 import { fileURLToPath } from 'url';
@@ -16,6 +16,7 @@ function loadSharedModule(modulePath, globalName) {
 const { buildWorkspaceFileMap, buildCronjobSkillMd, buildInfographicGeneratorSkillMd, buildInfographicGeneratorJs } = loadSharedModule('../setup/shared/workspace-gen.js', '__openclawWorkspace');
 const { buildOpenclawJson, buildEnvFileContent, buildExecApprovalsJson, buildZaloConnectChannelConfig } = loadSharedModule('../setup/shared/bot-config-gen.js', '__openclawBotConfig');
 const { buildDockerArtifacts } = loadSharedModule('../setup/shared/docker-gen.js', '__openclawDockerGen');
+const { HOST_UI_PS1, HOST_UI_PS1_VERSION } = loadSharedModule('../setup/shared/host-ui-ps1.js', '__openclawHostUiPs1');
 const { OPENCLAW_NPM_SPEC, NINE_ROUTER_NPM_SPEC, ZALO_CHANNEL_ID, ZALO_PLUGIN_ID, ZALO_CONNECT_VERSION, ZALO_CONNECT_PLUGIN_SPEC, build9RouterProviderConfig, get9RouterBaseUrl } = loadSharedModule('../setup/shared/common-gen.js', '__openclawCommon');
 const dataExport = loadSharedModule('../setup/data/index.js', '__openclawData');
 
@@ -24,7 +25,7 @@ const dataExport = loadSharedModule('../setup/data/index.js', '__openclawData');
 // scripts) runs a dedicated profile seeded from the operator's real one. Kept outside Chrome's
 // own folders: the block is an exact match on the default directory, and a sibling of it is a
 // needless bet on that staying true.
-const CHROME_SCRIPT_MARKER = 'OPENCLAW_CHROME_PROFILE_V2';
+const CHROME_SCRIPT_MARKER = 'OPENCLAW_CHROME_PROFILE_V3';
 const CHROME_DEBUG_PROFILE_LEAF_WIN = 'OpenClaw\\chrome-profile';
 const CHROME_DEBUG_PROFILE_LEAF_MAC = 'Library/Application Support/OpenClaw/chrome-profile';
 const CHROME_DEBUG_PROFILE_LEAF_LINUX = '.config/openclaw/chrome-profile';
@@ -104,6 +105,15 @@ async function pushBrowserScriptsIntoContainer(projectDir, aliases, files, sendL
   return pushed;
 }
 
+/**
+ * The browser-automation plugin defaults every high-impact behaviour to off (ClawHub's review reads
+ * broad defaults as "rogue agent", fairly). A dashboard install is an explicit, informed action, so
+ * the flags are turned on here — and stay visible in openclaw.json for anyone who wants them off.
+ */
+function browserAutomationOptIns() {
+  return { patchDocker: true, allowPageScripting: true, allowFileUpload: true };
+}
+
 async function patchBrowserAutomationHostPreference(projectDir, aliases = [], sendLog = () => {}) {
   const preferredCdpBlock = `const dns = require('dns').promises;
 const DEFAULT_CDP_URLS = [
@@ -200,9 +210,20 @@ async function connectPreferredChrome() {
     // the same way and does not care.
     'ping -n 3 127.0.0.1 >nul',
     '',
+    // Copying the real profile duplicates cookies, logins, history and extensions into a second
+    // directory and has to close every Chrome window to do it. That is the operator's call, not
+    // a silent default: without OPENCLAW_CHROME_SEED_PROFILE=1 this starts a clean profile and
+    // they sign in once, in the window that opens.
     'if not exist "%OPENCLAW_CHROME_PROFILE_DIR%\\Default" (',
     // No parentheses in text inside an if-block: cmd closes the block on the first ")".
-    '  echo Lan dau: dang dong Chrome de chep profile - cookie, dang nhap...',
+    '  echo Chua co profile dieu khien - se tao MOI va ban dang nhap 1 lan trong cua so vua mo.',
+    '  echo Muon dung san dang nhap cua Chrome thuong thi dat OPENCLAW_CHROME_SEED_PROFILE=1 roi chay lai.',
+    '  echo Luu y: viec do CHEP cookie, dang nhap, lich su, extension sang profile dieu khien',
+    '  echo va phai DONG het cua so Chrome dang mo de chep.',
+    ')',
+    '',
+    'if not exist "%OPENCLAW_CHROME_PROFILE_DIR%\\Default" if "%OPENCLAW_CHROME_SEED_PROFILE%"=="1" (',
+    '  echo Dang dong Chrome de chep profile theo yeu cau cua ban...',
     '  taskkill /F /IM chrome.exe >nul 2>&1',
     '  ping -n 4 127.0.0.1 >nul',
     '  echo Dang chep profile Chrome that sang "%OPENCLAW_CHROME_PROFILE_DIR%" ...',
@@ -214,7 +235,9 @@ async function connectPreferredChrome() {
     'echo Dang mo Chrome - profile: %OPENCLAW_CHROME_PROFILE_DIR%',
     'start "" "%CHROME_BIN%" ^',
     '  --remote-debugging-port=9222 ^',
-    '  --remote-allow-origins=* ^',
+    // Loopback only, and no --remote-allow-origins=*: a CDP client written in Node sends no
+    // Origin header, so the wildcard bought nothing and only widened who could drive Chrome.
+    '  --remote-debugging-address=127.0.0.1 ^',
     '  --user-data-dir="%OPENCLAW_CHROME_PROFILE_DIR%" ^',
     '  --profile-directory=Default ^',
     '  --no-first-run ^',
@@ -254,7 +277,8 @@ async function connectPreferredChrome() {
     'fi',
     '',
     '# Chrome 136+ refuses --remote-debugging-port on the default profile directory, so run a',
-    '# dedicated one seeded from the real profile (keeps cookies, logins, history, extensions).',
+    '# dedicated one. It starts empty: copying the real profile duplicates cookies and logins,',
+    '# so it only happens when the operator asks with OPENCLAW_CHROME_SEED_PROFILE=1.',
     ': "${OPENCLAW_CHROME_PROFILE_DIR:=$DEFAULT_DEBUG_PROFILE}"',
     '',
     'echo "Using: $CHROME_BIN"',
@@ -262,21 +286,28 @@ async function connectPreferredChrome() {
     'pkill -f -- "--remote-debugging-port=9222" 2>/dev/null || true',
     'sleep 2',
     '',
-    'if [ ! -d "$OPENCLAW_CHROME_PROFILE_DIR/Default" ] && [ -d "$REAL_PROFILE/Default" ]; then',
-    '  echo "First run: copying the real Chrome profile into $OPENCLAW_CHROME_PROFILE_DIR ..."',
-    '  mkdir -p "$OPENCLAW_CHROME_PROFILE_DIR/Default"',
-    '  cp -R "$REAL_PROFILE/Default/." "$OPENCLAW_CHROME_PROFILE_DIR/Default/" 2>/dev/null || true',
-    '  cp -f "$REAL_PROFILE/Local State" "$OPENCLAW_CHROME_PROFILE_DIR/Local State" 2>/dev/null || true',
-    `  for junk in ${chromeProfileCacheJunk.map((n) => `"${n}"`).join(' ')}; do`,
-    '    rm -rf "$OPENCLAW_CHROME_PROFILE_DIR/Default/$junk"',
-    '  done',
+    'if [ ! -d "$OPENCLAW_CHROME_PROFILE_DIR/Default" ]; then',
+    '  if [ "$OPENCLAW_CHROME_SEED_PROFILE" = "1" ] && [ -d "$REAL_PROFILE/Default" ]; then',
+    '    echo "Copying your real Chrome profile into $OPENCLAW_CHROME_PROFILE_DIR as requested"',
+    '    echo "(cookies, logins, history and extensions are duplicated into that directory)."',
+    '    mkdir -p "$OPENCLAW_CHROME_PROFILE_DIR/Default"',
+    '    cp -R "$REAL_PROFILE/Default/." "$OPENCLAW_CHROME_PROFILE_DIR/Default/" 2>/dev/null || true',
+    '    cp -f "$REAL_PROFILE/Local State" "$OPENCLAW_CHROME_PROFILE_DIR/Local State" 2>/dev/null || true',
+    `    for junk in ${chromeProfileCacheJunk.map((n) => `"${n}"`).join(' ')}; do`,
+    '      rm -rf "$OPENCLAW_CHROME_PROFILE_DIR/Default/$junk"',
+    '    done',
+    '  else',
+    '    echo "Starting a clean automation profile - sign in once in the window that opens."',
+    '    echo "To reuse your existing logins instead: OPENCLAW_CHROME_SEED_PROFILE=1 $0"',
+    '    echo "(that copies cookies, logins, history and extensions into the automation profile)."',
+    '  fi',
     'fi',
     'mkdir -p "$OPENCLAW_CHROME_PROFILE_DIR"',
     '',
     'echo "Starting Chrome (profile: $OPENCLAW_CHROME_PROFILE_DIR)..."',
     '"$CHROME_BIN" \\',
     '  --remote-debugging-port=9222 \\',
-    '  --remote-allow-origins=* \\',
+    '  --remote-debugging-address=127.0.0.1 \\',
     '  --user-data-dir="$OPENCLAW_CHROME_PROFILE_DIR" \\',
     '  --profile-directory=Default \\',
     '  --no-first-run \\',
@@ -561,7 +592,18 @@ function detectOs() {
   const platform = process.platform;
   if (platform === 'win32') return 'win';
   if (platform === 'darwin') return 'macos';
-  if (platform === 'linux') return os.release().toLowerCase().includes('microsoft') ? 'linux-desktop' : 'linux-desktop';
+  if (platform === 'linux') {
+    // WSL always has a Windows desktop behind it, so it counts as a desktop. Otherwise a session
+    // with no display server is a headless server, and the distinction is not cosmetic: 'vps' is
+    // what opens the gateway bind past loopback (bot-config-gen) — pick 'linux-desktop' on a VPS
+    // and the dashboard is only reachable through an SSH tunnel, while the browser tooling is set
+    // up as though a local Chrome existed.
+    if (os.release().toLowerCase().includes('microsoft')) return 'linux-desktop';
+    const sessionType = String(process.env.XDG_SESSION_TYPE || '').toLowerCase();
+    const hasDisplay = !!(process.env.DISPLAY || process.env.WAYLAND_DISPLAY || process.env.XDG_CURRENT_DESKTOP)
+      || sessionType === 'x11' || sessionType === 'wayland';
+    return hasDisplay ? 'linux-desktop' : 'vps';
+  }
   return 'linux-desktop';
 }
 
@@ -690,17 +732,58 @@ function run(cmd, args, opts = {}) {
   });
 }
 
+// Where npm puts global packages, derived from the running node binary so we never pay for
+// `npm root -g` (~100ms) just to find a version string.
+function globalNodeModulesDirs() {
+  const dirs = [];
+  const nodeDir = dirname(process.execPath);
+  dirs.push(join(nodeDir, '..', 'lib', 'node_modules'));      // unix prefix layout
+  dirs.push(join(nodeDir, 'node_modules'));                   // windows npm prefix
+  if (process.env.APPDATA) dirs.push(join(process.env.APPDATA, 'npm', 'node_modules'));
+  dirs.push('/usr/local/lib/node_modules', '/usr/lib/node_modules', '/opt/homebrew/lib/node_modules');
+  return dirs;
+}
+
+// `9router --version` boots the whole CLI and takes ~4 SECONDS on a normal machine. /api/system
+// used to pay that on every single call — and the UI calls it after every action, so the whole
+// dashboard felt slow for one version string. The version is right there in package.json.
+function readGlobalPackageVersion(name) {
+  for (const dir of globalNodeModulesDirs()) {
+    const pkg = join(dir, name, 'package.json');
+    try {
+      if (!existsSync(pkg)) continue;
+      const version = String(JSON.parse(readFileSync(pkg, 'utf8')).version || '').trim();
+      if (version) return version;
+    } catch {}
+  }
+  return '';
+}
+
 async function getCurrentRuntimeVersions() {
-  const [openclaw, nineRouter, node] = await Promise.all([
-    commandExists('openclaw', ['--version']),
-    commandExists('9router', ['--version']),
-    commandExists('node', ['--version']),
-  ]);
-  return {
-    openclaw: openclaw.ok ? (openclaw.output.split(/\r?\n/)[0] || '').trim() : '',
-    nineRouter: nineRouter.ok ? (nineRouter.output.split(/\r?\n/)[0] || '').trim() : '',
-    node: node.ok ? (node.output.split(/\r?\n/)[0] || '').trim() : process.version,
+  const ck = 'hostver:runtimes';
+  const cached = probeCacheGet(ck);
+  if (cached) return cached;
+
+  const fromDisk = {
+    openclaw: readGlobalPackageVersion('openclaw'),
+    nineRouter: readGlobalPackageVersion('9router'),
+    node: process.version || '',
   };
+  // Only shell out for what disk did not answer — a global install in a prefix we do not know
+  // about, mostly. Still cached, so an odd layout costs the slow probe once, not every request.
+  const needCli = !fromDisk.openclaw || !fromDisk.nineRouter;
+  if (needCli) {
+    const [openclaw, nineRouter] = await Promise.all([
+      fromDisk.openclaw ? null : commandExists('openclaw', ['--version']),
+      fromDisk.nineRouter ? null : commandExists('9router', ['--version']),
+    ]);
+    if (openclaw?.ok) fromDisk.openclaw = (openclaw.output.split(/\r?\n/)[0] || '').trim();
+    if (nineRouter?.ok) fromDisk.nineRouter = (nineRouter.output.split(/\r?\n/)[0] || '').trim();
+  }
+  // Versions only change on an install/update, and those paths already call probeCacheClear().
+  // The TTL is just a backstop for a package installed behind this server's back.
+  probeCacheSet(ck, fromDisk, 10 * 60 * 1000);
+  return fromDisk;
 }
 
 // Per-project cache for EXPENSIVE runtime/version probes (docker exec + openclaw CLI). These
@@ -716,8 +799,35 @@ function probeCacheGet(key) {
 }
 function probeCacheSet(key, value, ttlMs = 0) { _probeCache.set(key, { value, exp: ttlMs ? Date.now() + ttlMs : 0 }); }
 function probeCacheClear(prefix = '') {
-  if (!prefix) { _probeCache.clear(); return; }
+  if (!prefix) { _probeCache.clear(); _probeInflight.clear(); return; }
   for (const k of [..._probeCache.keys()]) if (k.startsWith(prefix)) _probeCache.delete(k);
+  for (const k of [..._probeInflight.keys()]) if (k.startsWith(prefix)) _probeInflight.delete(k);
+}
+
+// One probe per key at a time. The dashboard fires several requests at once and the startup
+// prefetch runs alongside them, so without this the same docker/CLI round-trip ran two or three
+// times over and every caller waited for the slowest copy. Serves a warm value immediately and
+// refreshes in the background once it is half-stale, so a click never waits on a probe.
+const _probeInflight = new Map();
+function sharedProbe(key, ttlMs, compute) {
+  const cached = probeCacheGet(key);
+  if (cached) {
+    if (Date.now() - cached.at > ttlMs / 2 && !_probeInflight.has(key)) {
+      const bg = compute()
+        .then((value) => { probeCacheSet(key, { value, at: Date.now() }, ttlMs); return value; })
+        .finally(() => _probeInflight.delete(key));
+      _probeInflight.set(key, bg);
+      bg.catch(() => {});
+    }
+    return Promise.resolve(cached.value);
+  }
+  const existing = _probeInflight.get(key);
+  if (existing) return existing;
+  const run = compute()
+    .then((value) => { probeCacheSet(key, { value, at: Date.now() }, ttlMs); return value; })
+    .finally(() => _probeInflight.delete(key));
+  _probeInflight.set(key, run);
+  return run;
 }
 
 async function resolveProjectRuntimeVersions(projectDir, mode = state.mode || 'docker') {
@@ -815,6 +925,11 @@ function runCapture(cmd, args, opts = {}) {
       windowsHide: opts.windowsHide ?? true,
       env: { ...process.env, ...(opts.env || {}) },
     });
+    // Some callers need to feed stdin (pbcopy/xclip take the clipboard text that way).
+    if (opts.input != null) {
+      try { child.stdin.write(String(opts.input)); } catch (_) {}
+      try { child.stdin.end(); } catch (_) {}
+    }
     let timedOut = false;
     const timer = Number.isFinite(opts.timeout) && opts.timeout > 0
       ? setTimeout(() => {
@@ -1657,6 +1772,25 @@ function portStatus(port) {
   });
 }
 
+/**
+ * First port at or after `start` that nothing on this host is listening on.
+ *
+ * The install-time allocator only knows about setup-managed projects, so it cannot see a docker
+ * project from another install, an SSH tunnel forwarding a remote bot's ports, or any other
+ * listener. Docker tolerates that (compose publishes into loopback and fails loudly on a clash);
+ * native binds the host directly, so it has to ask the host.
+ *
+ * `reserveNext` also requires port+1 to be free — that is where the zalo-mod dashboard lands.
+ */
+async function findFreeHostPort(start, { reserveNext = false, limit = 100 } = {}) {
+  for (let port = start; port < start + limit; port++) {
+    if ((await portStatus(port)) === 'online') continue;
+    if (reserveNext && (await portStatus(port + 1)) === 'online') continue;
+    return port;
+  }
+  return start;
+}
+
 async function buildBotStatus() {
   if (state.projectDir) await syncRuntimeState(state.projectDir).catch(() => {});
   const [gatewayStatus, routerStatus, bots, runtimeVersions] = await Promise.all([
@@ -2006,6 +2140,35 @@ async function waitForDockerContainer(name, timeoutMs = 30000) {
   return false;
 }
 
+/**
+ * Drop OpenClaw's boxed "Config warnings" banner (and any stray warning line) from CLI output.
+ *
+ * The banner prints on EVERY invocation and quotes the offending config keys verbatim, so a project
+ * whose zalo-connect plugin is missing has `channels.zalo-connect: unknown channel id: zalo-connect`
+ * in the output of *any* command. A readiness check that greps stdout for a channel id therefore
+ * reports "channel loaded" precisely when the plugin is absent — the check inverts itself. Strip the
+ * warnings before matching so only real command output counts.
+ */
+function stripCliWarnings(text = '') {
+  const kept = [];
+  let inBanner = false;
+  for (const line of String(text).split(/\r?\n/)) {
+    if (/◇\s*Config warnings/.test(line)) { inBanner = true; continue; }
+    // The banner is drawn as a box; its bottom edge is the only line starting with ├ or └.
+    if (inBanner) {
+      if (/^\s*[├└]/.test(line)) inBanner = false;
+      continue;
+    }
+    if (/unknown channel id|plugin not found|stale config|no channel plugin is installed/i.test(line)) continue;
+    kept.push(line);
+  }
+  return kept.join('\n');
+}
+
+// Both keywords are load-bearing, and callers must not narrow them to the id alone: `channels
+// status` lists a loaded channel by its DISPLAY NAME ("OpenClaw Zalo Connect default: enabled, …"),
+// so the hyphenated id shows up only in the stale-config warnings stripCliWarnings now removes.
+// Match on the id alone and the check can never pass once the plugin is actually installed.
 async function waitForGatewayZaloReady(botContainer, projectDir, timeoutMs = 90000, channelKeywords = ['zalo-connect', 'openclaw zalo connect']) {
   const started = Date.now();
   // Use dynamic port from env: OPENCLAW_GATEWAY_PORT → OPENCLAW_PORT → fallback 18789
@@ -2020,7 +2183,7 @@ async function waitForGatewayZaloReady(botContainer, projectDir, timeoutMs = 900
       const status = String(out.stdout || '').trim();
       if (status === 'READY') {
         const pluginCheck = await runCapture('docker', ['exec', botContainer, 'sh', '-c', 'openclaw channels status 2>&1 || true'], { cwd: projectDir, shell: false });
-        const output = ((pluginCheck.stdout || '') + ' ' + (pluginCheck.stderr || '')).toLowerCase();
+        const output = stripCliWarnings((pluginCheck.stdout || '') + '\n' + (pluginCheck.stderr || '')).toLowerCase();
         if (channelKeywords.some((kw) => output.includes(kw))) {
           ready = true;
           break;
@@ -2044,13 +2207,21 @@ async function waitForNativeGatewayZaloReady(projectDir, timeoutMs = 90000, chan
   const started = Date.now();
   const meta = readNativeMeta(projectDir) || {};
   const port = String(meta.gatewayPort || state.gatewayPort || NATIVE_DEFAULT_GATEWAY_PORT);
+  const extDir = join(projectDir, '.openclaw', 'extensions', 'zalo-connect');
   let ready = false;
   let attempts = 0;
   while (Date.now() - started < timeoutMs) {
     attempts++;
+    // Decisive, free, and immune to the warning-banner trap above: with no plugin folder the channel
+    // cannot possibly be loaded, so return right away and let the caller install it instead of
+    // burning the whole timeout waiting for something that will never appear.
+    if (!existsSync(extDir)) {
+      sendLog('[zalo-connect] Plugin folder .openclaw/extensions/zalo-connect is absent — not waiting.');
+      return false;
+    }
     if (await probeHttpOk(`http://127.0.0.1:${port}/health`, 2500)) {
       const st = await ocCapture(projectDir, ['channels', 'status']).catch(() => ({ stdout: '', stderr: '' }));
-      const output = ((st.stdout || '') + ' ' + (st.stderr || '')).toLowerCase();
+      const output = stripCliWarnings((st.stdout || '') + '\n' + (st.stderr || '')).toLowerCase();
       if (channelKeywords.some((kw) => output.includes(kw))) { ready = true; break; }
       if (attempts > 2) sendLog('[zalo-connect] Gateway healthy but Zalo Connect is not loaded yet (' + Math.round((Date.now() - started) / 1000) + 's)...');
     } else if (attempts > 2 && attempts % 3 === 0) {
@@ -2063,6 +2234,8 @@ async function waitForNativeGatewayZaloReady(projectDir, timeoutMs = 90000, chan
 }
 
 async function startZaloLogin(projectDir, agentId = "") {
+  // A fresh login changes what channels status reports; do not serve the cached "not connected".
+  probeCacheClear(`zalohealth:${projectDir || ''}`);
   const cfgPath = join(projectDir, ".openclaw", "openclaw.json");
   if (!existsSync(cfgPath)) throw httpError(404, "openclaw.json not found");
   const cfg = JSON.parse(await fsp.readFile(cfgPath, "utf8"));
@@ -2098,20 +2271,17 @@ async function startZaloConnectLogin(projectDir, accountId = 'default') {
       // No container: the gateway runs as a managed service on the host. Wait for it to
       // report the zalo-connect channel; if it never does and the plugin folder is absent,
       // install it on the host (into this project's .openclaw/extensions) and reload.
-      const gatewayReady = await waitForNativeGatewayZaloReady(projectDir, 180000, ['zalo-connect']);
+      const gatewayReady = await waitForNativeGatewayZaloReady(projectDir, 180000);
       if (!gatewayReady) {
-        const extDir = join(projectDir, '.openclaw', 'extensions', 'zalo-connect');
-        if (!existsSync(extDir)) {
-          sendLog(`[zalo-connect] Plugin missing — installing ${ZALO_CONNECT_PLUGIN_SPEC} natively...`);
-          const inst = await ocCapture(projectDir, ['plugins', 'install', ZALO_CONNECT_PLUGIN_SPEC, '--force', '--acknowledge-clawhub-risk']);
-          const instOut = `${inst.stdout}\n${inst.stderr}`;
-          for (const line of instOut.split(/\r?\n/).filter(Boolean)) sendLog(`[zalo-connect] ${line}`);
-          if (/installed plugin/i.test(instOut) || existsSync(extDir)) {
-            await restartNativeRuntime(projectDir).catch((err) => sendLog(`[native] restart skipped/failed: ${err.message}`));
-            await waitForNativeGatewayZaloReady(projectDir, 180000, ['zalo-connect']);
-          } else {
-            sendLog('[zalo-connect] Cài plugin không thành công — thử lại bằng nút "Đăng nhập Zalo".');
-          }
+        // ensureNativePlugins is the single place that knows what a native project owes itself, and
+        // it skips whatever is already on disk — so this covers learning-memory too, and reconnects
+        // on a healthy project cost nothing.
+        const installed = await ensureNativePlugins(projectDir);
+        if (installed.includes(ZALO_PLUGIN_ID)) {
+          await restartNativeRuntime(projectDir).catch((err) => sendLog(`[native] restart skipped/failed: ${err.message}`));
+          await waitForNativeGatewayZaloReady(projectDir, 180000);
+        } else if (!existsSync(join(projectDir, '.openclaw', 'extensions', 'zalo-connect'))) {
+          sendLog('[zalo-connect] Cài plugin không thành công — thử lại bằng nút "Đăng nhập Zalo".');
         }
       }
     } else {
@@ -2124,7 +2294,7 @@ async function startZaloConnectLogin(projectDir, accountId = 'default') {
       // backend-aware entrypoint existed).
       const containerUp = await waitForDockerContainer(botContainer, 90000);
       if (!containerUp) sendLog(`[zalo-connect] ${botContainer} chưa chạy sau 90s — vẫn thử tiếp...`);
-      const gatewayReady = await waitForGatewayZaloReady(botContainer, projectDir, 180000, ['zalo-connect']);
+      const gatewayReady = await waitForGatewayZaloReady(botContainer, projectDir, 180000);
       if (!gatewayReady) {
         const check = await runCapture('docker', ['exec', botContainer, 'sh', '-lc', '[ -d "${OPENCLAW_HOME:-/home/node/project/.openclaw}/extensions/zalo-connect" ] && echo OK || echo MISSING'], { cwd: projectDir, shell: false }).catch(() => ({ stdout: 'ERR' }));
         if (String(check.stdout || '').trim() === 'MISSING') {
@@ -2137,7 +2307,7 @@ async function startZaloConnectLogin(projectDir, accountId = 'default') {
             // Gateway must reload to pick the plugin up — safe here: the gateway is past
             // its boot (we only reach this branch when it answered the exec above).
             await restartDockerBotContainer(projectDir).catch((err) => sendLog(`[docker] restart skipped/failed: ${err.message}`));
-            await waitForGatewayZaloReady(botContainer, projectDir, 180000, ['zalo-connect']);
+            await waitForGatewayZaloReady(botContainer, projectDir, 180000);
           } else {
             sendLog('[zalo-connect] Cài plugin không thành công — thử lại bằng nút "Đăng nhập Zalo" sau khi container ổn định.');
           }
@@ -2321,7 +2491,17 @@ function buildZaloHealthSnapshot(cfg = {}, statusJson = null, credentialNames =
 // ── Zalo health snapshot for the dashboard ──────────────────────────────────────
 // Runtime JSON is authoritative and account-aware. Text parsing remains only as a
 // compatibility fallback for older OpenClaw builds.
-async function getZaloHealth(projectDir) {
+// `openclaw channels status` is a CLI round-trip (docker exec on a container, or the host
+// gateway) and costs ~3 seconds. The dashboard asks for this on every page load and after every
+// action, so it is cached for a few seconds and refreshed in the background: a second visit is
+// instant, and the number on screen is never more than a few seconds stale. Login/restart paths
+// clear it (probeCacheClear) so a state change shows up immediately.
+const ZALO_HEALTH_TTL_MS = 4000;
+function getZaloHealth(projectDir) {
+  return sharedProbe(`zalohealth:${projectDir || ''}`, ZALO_HEALTH_TTL_MS, () => computeZaloHealth(projectDir));
+}
+
+async function computeZaloHealth(projectDir) {
   const meta = {
     supportedVersion: ZALO_CONNECT_VERSION,
     installedVersion: null,
@@ -2338,19 +2518,24 @@ async function getZaloHealth(projectDir) {
   if (meta.zaloModVersion) meta.zaloModInstalled = true;
 
   const botContainer = getBotContainerName(projectDir);
+  const native = isNativeProject(projectDir);
   if (cfg.channels?.['zalo-connect']?.enabled) {
     const manifestHost = join(projectDir, '.openclaw', 'extensions', 'zalo-connect', 'openclaw.plugin.json');
     try {
       meta.installedVersion = JSON.parse(await fsp.readFile(manifestHost, 'utf8')).version || null;
     } catch {
-      try {
-        const r = await runCapture('docker', ['exec', botContainer, 'sh', '-lc', 'cat "${OPENCLAW_HOME:-/home/node/project/.openclaw}/extensions/zalo-connect/openclaw.plugin.json" 2>/dev/null'], { cwd: projectDir, shell: false, timeout: 8000 });
-        meta.installedVersion = JSON.parse(String(r.stdout || '{}')).version || null;
-      } catch {}
+      // Only Docker projects keep the manifest inside a container. A native project has no
+      // container at all, and this fallback used to shell into one anyway — seconds of waiting on
+      // a `docker exec` that could never succeed, on a request the dashboard makes constantly.
+      if (!native) {
+        try {
+          const r = await runCapture('docker', ['exec', botContainer, 'sh', '-lc', 'cat "${OPENCLAW_HOME:-/home/node/project/.openclaw}/extensions/zalo-connect/openclaw.plugin.json" 2>/dev/null'], { cwd: projectDir, shell: false, timeout: 8000 });
+          meta.installedVersion = JSON.parse(String(r.stdout || '{}')).version || null;
+        } catch {}
+      }
     }
   }
 
-  const native = isNativeProject(projectDir);
   let containerRunning = false;
   let statusJson = null;
   let textStatus = '';
@@ -2360,7 +2545,9 @@ async function getZaloHealth(projectDir) {
     // /health over loopback, then read channel status + credentials directly on the host.
     const nmeta = readNativeMeta(projectDir) || {};
     const port = String(nmeta.gatewayPort || state.gatewayPort || NATIVE_DEFAULT_GATEWAY_PORT);
-    containerRunning = await probeHttpOk(`http://127.0.0.1:${port}/health`, 2500);
+    // Loopback: a live gateway answers in milliseconds. The old 2.5s budget was pure waiting
+    // whenever the runtime was down, on a request the dashboard makes on every page load.
+    containerRunning = await probeHttpOk(`http://127.0.0.1:${port}/health`, 900);
     if (containerRunning) {
       try {
         const r = await ocCapture(projectDir, ['channels', 'status', '--json'], { timeout: 20000 });
@@ -2446,10 +2633,13 @@ function getBotServiceName(projectDir) {
 // single fixed one, so without this a second native project would take over the first's service.
 
 const NATIVE_MARKER = 'native.json';
-// Native ports sit one hundred above the docker ones (18789/20128) so a native project can run
-// next to a docker project — or next to an SSH tunnel forwarding a remote bot's ports — untouched.
-const NATIVE_DEFAULT_GATEWAY_PORT = 18889;
-const NATIVE_DEFAULT_ROUTER_PORT = 20228;
+// Native uses the same ports as everything else: openclaw's 18789 and 9router's 20128. It used to
+// jump a hundred above them unconditionally so it could sit next to a docker project, but that fired
+// even on a machine with nothing running at all — a fresh VPS still landed on 18889/20228, so every
+// tunnel command, bookmark and doc pointed at a port the user never chose. findFreeHostPort() now
+// handles coexistence by asking the host what is actually taken, which the fixed offset never did.
+const NATIVE_DEFAULT_GATEWAY_PORT = 18789;
+const NATIVE_DEFAULT_ROUTER_PORT = 20128;
 
 function nativeMarkerPath(projectDir) {
   return join(projectDir || state.projectDir || '', '.openclaw', NATIVE_MARKER);
@@ -2521,6 +2711,47 @@ function ocCapture(projectDir, args, opts = {}) {
   return runCapture(a.cmd, a.args, { shell: false, ...a.opts, ...opts, env: { ...(a.opts.env || {}), ...(opts.env || {}) } });
 }
 
+/** Probe the managed gateway's own /health until it answers. */
+async function waitForNativeGatewayHealthy(projectDir, timeoutMs = 120000) {
+  const meta = readNativeMeta(projectDir) || {};
+  const port = String(meta.gatewayPort || state.gatewayPort || NATIVE_DEFAULT_GATEWAY_PORT);
+  const started = Date.now();
+  let attempts = 0;
+  while (Date.now() - started < timeoutMs) {
+    if (await probeHttpOk(`http://127.0.0.1:${port}/health`, 2500)) return true;
+    attempts++;
+    if (attempts % 5 === 0) sendLog(`[native] Waiting for gateway on ${port}... (${Math.round((Date.now() - started) / 1000)}s)`);
+    await new Promise((r) => setTimeout(r, 3000));
+  }
+  sendLog(`[native] Gateway did not answer /health on ${port} within ${Math.round(timeoutMs / 1000)}s.`);
+  return false;
+}
+
+/**
+ * The first gateway boot runs OpenClaw's startup migrations under a state-directory lease, and a
+ * second gateway that tries to start meanwhile exits 1 with this message rather than waiting. The
+ * docker path sidesteps it by never poking a booting container (see startZaloConnectLogin); when we
+ * do hit it natively, the message carries the exact instant the lease frees — so wait that out
+ * instead of retrying blind into systemd's StartLimitBurst (5 per 60s, after which the unit is
+ * abandoned for good).
+ */
+function migrationLeaseDeadline(text = '') {
+  const m = String(text).match(/migrations are already running[\s\S]*?after\s+(\d{4}-\d{2}-\d{2}T[\d:.]+Z)/i);
+  if (!m) return 0;
+  const t = Date.parse(m[1]);
+  return Number.isFinite(t) ? t : 0;
+}
+
+/** `openclaw daemon <verb>` for a native project: streams output to the UI log AND returns it. */
+async function ocDaemon(projectDir, verb, extraArgs = []) {
+  const args = ['daemon', verb, ...extraArgs];
+  sendLog(`$ openclaw ${args.join(' ')}`);
+  const out = await runCapture('openclaw', args, { cwd: projectDir, env: nativeEnv(projectDir), shell: false, timeout: 120000 });
+  const text = `${out.stdout || ''}\n${out.stderr || ''}`;
+  for (const line of text.split(/\r?\n/).map((l) => l.trimEnd()).filter(Boolean)) sendLog(line);
+  return { ...out, text };
+}
+
 /**
  * Restart the native gateway service.
  *
@@ -2529,20 +2760,105 @@ function ocCapture(projectDir, args, opts = {}) {
  * newly installed plugins never load, silently). stop+start is what actually works there, and it
  * works everywhere else too, so Windows takes that path and other systems keep `restart` with
  * stop+start as a fallback.
+ *
+ * Health is confirmed over /health at the end rather than trusted from the CLI's exit code: the
+ * CLI gives up verifying after ~13s while the generated unit allows 30s to start, so a slow but
+ * perfectly healthy gateway reports "restart failed" — which used to send callers down a pointless
+ * stop+start that raced the migration lease all over again.
  */
 async function restartNativeRuntime(projectDir) {
-  const env = nativeEnv(projectDir);
   const stopStart = async () => {
-    await run('openclaw', ['daemon', 'stop'], { cwd: projectDir, env }).catch(() => {});
-    await run('openclaw', ['daemon', 'start'], { cwd: projectDir, env });
+    await ocDaemon(projectDir, 'stop');
+    return ocDaemon(projectDir, 'start');
   };
-  if (process.platform === 'win32') return stopStart();
-  try {
-    await run('openclaw', ['daemon', 'restart'], { cwd: projectDir, env });
-  } catch (e) {
-    sendLog(`[native] daemon restart failed (${e.message}); falling back to stop+start`);
-    await stopStart();
+  let res;
+  if (process.platform === 'win32') {
+    res = await stopStart();
+  } else {
+    res = await ocDaemon(projectDir, 'restart');
+    // A lease collision is a "come back in a moment", not a broken service: stop+start would only
+    // collide again, so fall through to the wait below instead.
+    if (res.code !== 0 && !migrationLeaseDeadline(res.text)) {
+      sendLog(`[native] daemon restart exited ${res.code}; falling back to stop+start`);
+      res = await stopStart();
+    }
+  }
+  const deadline = migrationLeaseDeadline(res.text);
+  if (deadline) {
+    const waitMs = Math.max(0, Math.min(deadline - Date.now(), 300000)) + 3000;
+    sendLog(`[native] Startup migrations hold the state lease — waiting ${Math.ceil(waitMs / 1000)}s before retrying.`);
+    await new Promise((r) => setTimeout(r, waitMs));
+    res = await ocDaemon(projectDir, 'restart');
+    if (res.code !== 0) res = await stopStart();
   }
+  // systemd keeps restarting a crash-looping unit every RestartSec, so a gateway blocked by a lease
+  // we never saw still comes up on its own — give it room before calling the restart a failure.
+  if (!(await waitForNativeGatewayHealthy(projectDir, 180000))) {
+    throw new Error('gateway did not answer /health after restart');
+  }
+  return true;
+}
+
+/**
+ * `openclaw daemon install` has no `--system` flag, so on Linux the gateway becomes a systemd USER
+ * unit — and a user manager without linger is torn down when that user's last session exits. On a
+ * desktop the graphical session holds it open, which is why this never showed up on macOS or a
+ * Linux desktop; on a VPS the bot dies the moment the operator closes SSH and never comes back
+ * after a reboot. Linger is what makes a user unit behave like the `restart: always` container it
+ * replaces. Best-effort: a box without loginctl just keeps the old behaviour, loudly.
+ */
+async function ensureSystemdLinger() {
+  if (process.platform !== 'linux') return false;
+  let user = '';
+  try { user = process.env.SUDO_USER || os.userInfo().username; } catch { return false; }
+  if (!user) return false;
+  const cur = await runCapture('loginctl', ['show-user', user, '-p', 'Linger'], { shell: false, timeout: 10000 });
+  if (/Linger=yes/i.test(cur.stdout || '')) return true;
+  const out = await runCapture('loginctl', ['enable-linger', user], { shell: false, timeout: 20000 });
+  if (out.code === 0) {
+    sendLog(`[native] systemd linger enabled for "${user}" — the gateway now survives logout and reboot.`);
+    return true;
+  }
+  sendLog(`[native] WARNING: could not enable systemd linger for "${user}" (${(out.stderr || out.stdout || '').trim() || `exit ${out.code}`}).`);
+  sendLog(`[native] The gateway will stop when this user's last session ends. Fix it with: sudo loginctl enable-linger ${user}`);
+  return false;
+}
+
+/**
+ * Native counterpart of the docker entrypoint's `ensure_plugin` (docker-gen.js).
+ *
+ * A container reinstalls its missing plugins on every boot; a native project has no entrypoint, so
+ * nothing ever put zalo-connect or learning-memory on disk. The generated config declares both
+ * anyway (bot-config-gen writes plugins.entries + allow + slots.contextEngine), so without this the
+ * gateway boots with "plugin not found" warnings, `channels.zalo-connect` has no owner — Zalo login
+ * fails with `Unsupported channel "zalo-connect"` — and the bot silently runs with no context
+ * engine at all. Same set and same skip-if-present cheapness as ensure_plugin.
+ */
+async function ensureNativePlugins(projectDir, { restart = false } = {}) {
+  if (!isNativeProject(projectDir)) return [];
+  let cfg = {};
+  try { cfg = JSON.parse(await fsp.readFile(join(projectDir, '.openclaw', 'openclaw.json'), 'utf8')); } catch {}
+  // learning-memory backs plugins.slots.contextEngine for every bot; zalo-connect only when a bot
+  // actually declares the channel (mirrors docker-gen's `if (zaloBackend === 'zalo-connect')`).
+  const wanted = new Set(['learning-memory']);
+  if (cfg?.channels?.[ZALO_CHANNEL_ID] || cfg?.plugins?.entries?.[ZALO_PLUGIN_ID]) wanted.add(ZALO_PLUGIN_ID);
+  const installed = [];
+  for (const id of wanted) {
+    const dir = join(projectDir, '.openclaw', 'extensions', id);
+    if (existsSync(dir)) continue;
+    const spec = id === ZALO_PLUGIN_ID ? ZALO_CONNECT_PLUGIN_SPEC : pluginInstallSpec(id);
+    sendLog(`[native] plugin ${id} missing; installing ${spec}`);
+    const out = await ocCapture(projectDir, ['plugins', 'install', spec, '--force', '--acknowledge-clawhub-risk'], { timeout: 300000 });
+    const text = `${out.stdout || ''}\n${out.stderr || ''}`;
+    for (const line of text.split(/\r?\n/).map((l) => l.trimEnd()).filter(Boolean)) sendLog(`[native] ${line}`);
+    if (existsSync(dir) || /installed plugin/i.test(text)) installed.push(id);
+    else sendLog(`[native] WARNING: could not install plugin ${id} — the bot will run without it.`);
+  }
+  if (installed.length && restart) {
+    sendLog(`[native] Restarting gateway to load: ${installed.join(', ')}`);
+    await restartNativeRuntime(projectDir).catch((e) => sendLog(`[native] restart after plugin install: ${e.message}`));
+  }
+  return installed;
 }
 
 /** Fire-and-forget background process (9router has no service wrapper of its own). */
@@ -2646,11 +2962,20 @@ async function startNativeRuntime({ projectDir, osChoice = '', gatewayPort, rout
   await new Promise((r) => setTimeout(r, 8000));
   await applyResolved9RouterApiKey(projectDir).catch(() => {});
 
+  // Plugins BEFORE the gateway's first boot — the container entrypoint installs them ahead of the
+  // gateway for the same reason: a gateway that boots with its plugins already on disk loads them
+  // straight away, needs no follow-up restart, and prints no "plugin not found" warnings.
+  await ensureNativePlugins(projectDir).catch((e) => sendLog(`[native] plugin bootstrap skipped: ${e.message}`));
+
   // Managed service = auto-restart (KeepAlive/Restart=always) and start-at-login, the native
   // equivalent of docker's `restart: always`. --force so re-running install updates the port.
   const env = nativeEnv(projectDir);
+  await ensureSystemdLinger();
   await run('openclaw', ['daemon', 'install', '--force', '--port', String(gwPort)], { cwd: projectDir, env });
   await run('openclaw', ['daemon', 'start'], { cwd: projectDir, env });
+  // Let the first boot finish its state migrations here, while nothing else is competing for the
+  // lease. Every later action (create bot, install plugin) then restarts a settled gateway.
+  await waitForNativeGatewayHealthy(projectDir, 180000);
   sendLog(`[native] gateway service "${label}" running on 127.0.0.1:${gwPort}, 9router on 127.0.0.1:${rtPort}`);
   return { gatewayPort: gwPort, routerPort: rtPort, label };
 }
@@ -2799,6 +3124,14 @@ async function recreateDockerBot(projectDir) {
   // Native: there is no image to rebuild — the gateway reads openclaw.json from disk on boot, so
   // reloading config after a bot/plugin change is just a service restart. Callers stay unchanged.
   if (isNativeProject(projectDir)) {
+    // Never restart a gateway that is still on its first boot: OpenClaw runs startup migrations
+    // under a state lease, a restart mid-migration exits 1, and systemd's start limit can then
+    // abandon the unit. This is the same trap the docker path avoids by waiting for the container
+    // before touching it (see startZaloConnectLogin) — wait for /health first.
+    await waitForNativeGatewayHealthy(projectDir, 180000);
+    // The bot that was just created/edited may have added the Zalo channel or the context engine to
+    // openclaw.json; put those plugins on disk now so this one reload loads them too.
+    await ensureNativePlugins(projectDir).catch((e) => sendLog(`[native] plugin ensure skipped: ${e.message}`));
     sendLog('[native] Reloading gateway to pick up openclaw.json changes...');
     await restartNativeRuntime(projectDir).catch((e) => sendLog(`[native] restart failed: ${e.message}`));
     probeCacheClear();
@@ -3160,13 +3493,58 @@ function whichSync(name) {
   try {
     const finder = process.platform === 'win32' ? 'where' : 'which';
     const out = execFileSync(finder, [name], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
-    const first = String(out).split(/\r?\n/).map((s) => s.trim()).find(Boolean);
-    return first || '';
+    const hits = String(out).split(/\r?\n/).map((s) => s.trim()).filter(Boolean);
+    if (process.platform !== 'win32') return hits[0] || '';
+    // `where claude` lists the extensionless npm shim FIRST — a shell script Windows cannot spawn
+    // ("spawn ...\\npm\\claude ENOENT"), which is how an allow-listed CLI ended up unusable for the
+    // bot. Prefer something Windows can actually execute.
+    const rank = (f) => {
+      const ext = extname(f).toLowerCase();
+      const order = ['.exe', '.cmd', '.bat', '.com', '.ps1'];
+      const idx = order.indexOf(ext);
+      return idx === -1 ? order.length : idx;
+    };
+    return [...hits].sort((a, b) => rank(a) - rank(b))[0] || '';
   } catch (_) {
     return '';
   }
 }
 
+/**
+ * What to actually spawn for an allow-listed command. Windows needs the indirection:
+ *  - the path may be the extensionless npm shim (a shell script) — try the real siblings;
+ *  - a `.cmd`/`.bat` shim cannot be spawned without a shell on current Node, so read it and run
+ *    what it points at (`…\pkg\bin\x.exe`, or node + a cli.js) directly.
+ * Keeping shell:false matters: the bot supplies the arguments, and a shell would let one of them
+ * become a second command.
+ */
+function resolveHostExecutable(bin) {
+  if (process.platform !== 'win32') return { file: bin, prefixArgs: [] };
+  let target = bin;
+  if (!extname(target)) {
+    const candidate = ['.exe', '.cmd', '.bat'].map((ext) => target + ext).find((f) => existsSync(f));
+    if (candidate) target = candidate;
+  }
+  const ext = extname(target).toLowerCase();
+  if (ext !== '.cmd' && ext !== '.bat') return { file: target, prefixArgs: [] };
+  try {
+    const shim = readFileSync(target, 'utf8');
+    const dir = dirname(target);
+    const expand = (p) => resolve(dir, p.replace(/%~?dp0%\\?/gi, '').replace(/^\\+/, ''));
+    const exeRef = shim.match(/"([^"\n]*?\.exe)"/i);
+    if (exeRef) {
+      const exe = expand(exeRef[1]);
+      if (existsSync(exe)) return { file: exe, prefixArgs: [] };
+    }
+    const jsRef = shim.match(/"([^"\n]*?\.js)"/i);
+    if (jsRef) {
+      const js = expand(jsRef[1]);
+      if (existsSync(js)) return { file: process.execPath, prefixArgs: [js] };
+    }
+  } catch (_) {}
+  return { file: target, prefixArgs: [] };
+}
+
 /**
  * CLI tools the bot may RUN (not just open) via /api/host/exec — output is captured and
  * returned. Kept as a name→path allow-list, mirroring detectHostApps: the executable is fixed,
@@ -3231,6 +3609,13 @@ function grantHostCapabilities(cfg) {
       added.push(name);
     }
   }
+  // Desktop actions (/api/host/ui) come with the same grant: screenshot, pointer, keyboard,
+  // clipboard, windows. Built in, so they work on a machine with no Codex and no extra tools —
+  // on Linux they lean on xdotool/scrot, which the endpoint reports if missing.
+  if (cfg.ui !== true) {
+    cfg.ui = true;
+    added.push('desktop actions (screenshot/click/type)');
+  }
   return added;
 }
 
@@ -3502,7 +3887,8 @@ function runHostCommand(res, name, bin, args, input, timeoutMs) {
     };
     let child;
     try {
-      child = spawn(bin, args, { shell: false, windowsHide: true });
+      const target = resolveHostExecutable(bin);
+      child = spawn(target.file, [...target.prefixArgs, ...args], { shell: false, windowsHide: true });
     } catch (e) {
       return finish({ ok: false, error: e.message }, 500);
     }
@@ -3522,6 +3908,262 @@ function runHostCommand(res, name, bin, args, input, timeoutMs) {
   });
 }
 
+/**
+ * Desktop actions for the bot: see the screen, move and click, type, read the clipboard, list and
+ * focus windows. The bot runs in a container with no desktop of its own, so the installer — which
+ * already runs on the operator's machine and already opens apps for it — performs them.
+ *
+ * No native modules: the approach follows the dependency-free tools (and Anthropic's own
+ * computer-use reference, which drives xdotool + a screenshot binary):
+ *   Windows  a version-stamped PowerShell helper (user32 P/Invoke, SendKeys, System.Drawing)
+ *   macOS    screencapture + osascript/System Events + pbcopy/pbpaste
+ *   Linux    xdotool + scrot|import|gnome-screenshot|spectacle + xclip|wl-copy
+ * Whatever the OS, the bot sends the same JSON and gets the same shape back, so its instructions
+ * do not fork per platform.
+ *
+ * Windows note: input injection and screen capture need a real desktop session. When the installer
+ * itself was started over SSH there is none, and the capture fails — the error says so instead of
+ * leaking a raw Win32Exception.
+ */
+const HOST_UI_ACTIONS = new Set([
+  'screenshot', 'screen_size', 'mouse_move', 'click', 'drag', 'scroll',
+  'type', 'key', 'clipboard_get', 'clipboard_set', 'windows', 'focus',
+]);
+
+function hostUiScriptPath(projectDir) {
+  return join(projectDir, '.openclaw', 'host-ui.ps1');
+}
+
+async function ensureHostUiScript(projectDir) {
+  const path = hostUiScriptPath(projectDir);
+  const stamp = `# OpenClaw host UI helper — version ${HOST_UI_PS1_VERSION}`;
+  try {
+    if (existsSync(path) && (await fsp.readFile(path, 'utf8')).startsWith(stamp)) return path;
+  } catch (_) {}
+  await fsp.mkdir(dirname(path), { recursive: true }).catch(() => {});
+  await fsp.writeFile(path, HOST_UI_PS1, 'utf8');
+  return path;
+}
+
+function firstExistingCommand(names) {
+  for (const name of names) {
+    const bin = whichSync(name);
+    if (bin) return { name, bin };
+  }
+  return null;
+}
+
+async function hostUiScreenshotTarget(projectDir) {
+  const dir = join(projectDir, '.openclaw', 'media', 'host-ui');
+  await fsp.mkdir(dir, { recursive: true }).catch(() => {});
+  // Keep the folder from growing forever: the bot takes a lot of these.
+  try {
+    const files = (await fsp.readdir(dir)).filter((f) => f.endsWith('.png')).sort();
+    for (const stale of files.slice(0, Math.max(0, files.length - 20))) {
+      await fsp.rm(join(dir, stale), { force: true }).catch(() => {});
+    }
+  } catch (_) {}
+  const name = `shot-${new Date().toISOString().replace(/[:.]/g, '-')}.png`;
+  return { hostPath: join(dir, name), containerPath: `/home/node/project/.openclaw/media/host-ui/${name}` };
+}
+
+async function runHostUiWindows(projectDir, action, body, shot) {
+  const script = await ensureHostUiScript(projectDir);
+  const args = ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-File', script, '-Action', action];
+  const push = (flag, value) => { if (value !== undefined && value !== null && value !== '') args.push(flag, String(value)); };
+  push('-X', body.x);
+  push('-Y', body.y);
+  push('-ToX', body.toX);
+  push('-ToY', body.toY);
+  push('-Amount', body.amount);
+  push('-Text', body.text);
+  push('-Button', body.button);
+  push('-Clicks', body.clicks);
+  push('-Title', body.title);
+  if (shot) push('-Path', shot.hostPath);
+  const r = await runCapture('powershell', args, { shell: false, timeout: 30000 });
+  const parsed = parseJsonText(String(r.stdout || '').trim(), null);
+  if (parsed) return parsed;
+  const err = String(r.stderr || r.stdout || '').trim();
+  if (/Win32Exception|CopyFromScreen|handle is invalid/i.test(err)) {
+    return { ok: false, error: 'no desktop session available. The installer must run in the logged-in desktop session (not over SSH) for screen capture and input to work.' };
+  }
+  return { ok: false, error: err.split('\n')[0] || `powershell exited ${r.code}` };
+}
+
+async function runHostUiMac(action, body, shot) {
+  const osa = (script) => runCapture('osascript', ['-e', script], { shell: false, timeout: 20000 });
+  const point = () => `{${Number(body.x) || 0}, ${Number(body.y) || 0}}`;
+  switch (action) {
+    case 'screenshot': {
+      const r = await runCapture('screencapture', ['-x', shot.hostPath], { shell: false, timeout: 20000 });
+      return r.code === 0 ? { ok: true, path: shot.hostPath } : { ok: false, error: String(r.stderr || 'screencapture failed').trim() };
+    }
+    case 'screen_size': {
+      const r = await osa('tell application "Finder" to get bounds of window of desktop');
+      const nums = String(r.stdout || '').trim().split(/\s*,\s*/).map(Number);
+      return nums.length === 4 ? { ok: true, width: nums[2], height: nums[3] } : { ok: false, error: 'could not read screen bounds' };
+    }
+    case 'mouse_move':
+    case 'click': {
+      // System Events can click at a point; a plain move has no equivalent, so a move is a click
+      // target set-up only. Accessibility permission is required (System Settings → Privacy).
+      const clicks = Math.max(1, Number(body.clicks) || 1);
+      if (action === 'mouse_move') return { ok: true, note: 'macOS has no pointer-move without a click; pass x/y to click instead', x: body.x, y: body.y };
+      for (let i = 0; i < clicks; i++) {
+        const r = await osa(`tell application "System Events" to click at ${point()}`);
+        if (r.code !== 0) return { ok: false, error: String(r.stderr || '').trim() || 'click failed (grant Accessibility permission)' };
+      }
+      return { ok: true, button: 'left', clicks };
+    }
+    case 'type': {
+      const text = String(body.text || '').replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+      const r = await osa(`tell application "System Events" to keystroke "${text}"`);
+      return r.code === 0 ? { ok: true, typed: String(body.text || '').length } : { ok: false, error: String(r.stderr || '').trim() };
+    }
+    case 'key': {
+      const map = { enter: 'return', esc: 'escape', pageup: 'page up', pagedown: 'page down' };
+      for (const combo of String(body.text || '').split(/\s+/).filter(Boolean)) {
+        const parts = combo.toLowerCase().split('+').map((p) => p.trim()).filter(Boolean);
+        const key = map[parts[parts.length - 1]] || parts[parts.length - 1];
+        const mods = parts.slice(0, -1).map((m) => ({ ctrl: 'control down', control: 'control down', cmd: 'command down', meta: 'command down', alt: 'option down', option: 'option down', shift: 'shift down' })[m]).filter(Boolean);
+        const using = mods.length ? ` using {${mods.join(', ')}}` : '';
+        const named = ['return', 'escape', 'tab', 'space', 'delete', 'up', 'down', 'left', 'right', 'home', 'end', 'page up', 'page down'];
+        const script = named.includes(key)
+          ? `tell application "System Events" to key code ${{ return: 36, escape: 53, tab: 48, space: 49, delete: 51, up: 126, down: 125, left: 123, right: 124, home: 115, end: 119, 'page up': 116, 'page down': 121 }[key]}${using}`
+          : `tell application "System Events" to keystroke "${key}"${using}`;
+        const r = await osa(script);
+        if (r.code !== 0) return { ok: false, error: String(r.stderr || '').trim() };
+      }
+      return { ok: true, keys: body.text };
+    }
+    case 'scroll': {
+      const amount = Number(body.amount) || 3;
+      const dir = amount < 0 ? 121 : 116; // page down / page up
+      for (let i = 0; i < Math.abs(amount); i++) await osa(`tell application "System Events" to key code ${dir}`);
+      return { ok: true, amount };
+    }
+    case 'clipboard_get': {
+      const r = await runCapture('pbpaste', [], { shell: false, timeout: 10000 });
+      return { ok: true, text: String(r.stdout || '') };
+    }
+    case 'clipboard_set': {
+      const r = await runCapture('sh', ['-c', 'pbcopy'], { shell: false, timeout: 10000, input: String(body.text || '') });
+      return r.code === 0 ? { ok: true, length: String(body.text || '').length } : { ok: false, error: 'pbcopy failed' };
+    }
+    case 'windows': {
+      const r = await osa('tell application "System Events" to get name of every process whose background only is false');
+      const list = String(r.stdout || '').trim().split(/\s*,\s*/).filter(Boolean).map((title) => ({ title, process: title }));
+      return { ok: true, windows: list };
+    }
+    case 'focus': {
+      const title = String(body.title || '').replace(/"/g, '');
+      if (!title) return { ok: false, error: 'focus needs a title' };
+      const r = await osa(`tell application "${title}" to activate`);
+      return r.code === 0 ? { ok: true, focused: title } : { ok: false, error: String(r.stderr || '').trim() || `no app named ${title}` };
+    }
+    default:
+      return { ok: false, error: `unsupported on macOS: ${action}` };
+  }
+}
+
+async function runHostUiLinux(action, body, shot) {
+  const xdo = whichSync('xdotool');
+  const need = (bin, hint) => ({ ok: false, error: `${hint} needs ${bin}; install it (e.g. apt install ${bin})` });
+  switch (action) {
+    case 'screenshot': {
+      const tool = firstExistingCommand(['gnome-screenshot', 'scrot', 'spectacle', 'import']);
+      if (!tool) return need('scrot', 'screenshot');
+      const argv = tool.name === 'gnome-screenshot' ? ['-f', shot.hostPath]
+        : tool.name === 'spectacle' ? ['-b', '-n', '-o', shot.hostPath]
+          : tool.name === 'import' ? ['-window', 'root', shot.hostPath]
+            : [shot.hostPath];
+      const r = await runCapture(tool.bin, argv, { shell: false, timeout: 20000 });
+      return r.code === 0 ? { ok: true, path: shot.hostPath, tool: tool.name } : { ok: false, error: String(r.stderr || 'capture failed').trim() };
+    }
+    case 'screen_size': {
+      if (!xdo) return need('xdotool', 'screen_size');
+      const r = await runCapture(xdo, ['getdisplaygeometry'], { shell: false, timeout: 10000 });
+      const [w, h] = String(r.stdout || '').trim().split(/\s+/).map(Number);
+      return w && h ? { ok: true, width: w, height: h } : { ok: false, error: 'could not read display geometry' };
+    }
+    case 'mouse_move':
+    case 'click':
+    case 'drag':
+    case 'scroll':
+    case 'type':
+    case 'key':
+    case 'windows':
+    case 'focus': {
+      if (!xdo) return need('xdotool', action);
+      const button = { left: 1, middle: 2, right: 3 }[String(body.button || 'left')] || 1;
+      const argvFor = {
+        mouse_move: ['mousemove', String(body.x ?? 0), String(body.y ?? 0)],
+        click: ['mousemove', String(body.x ?? 0), String(body.y ?? 0), 'click', '--repeat', String(Math.max(1, Number(body.clicks) || 1)), String(button)],
+        drag: ['mousemove', String(body.x ?? 0), String(body.y ?? 0), 'mousedown', '1', 'mousemove', String(body.toX ?? 0), String(body.toY ?? 0), 'mouseup', '1'],
+        scroll: ['click', '--repeat', String(Math.max(1, Math.abs(Number(body.amount) || 3))), (Number(body.amount) || 3) < 0 ? '5' : '4'],
+        type: ['type', '--delay', '12', '--', String(body.text || '')],
+        key: ['key', ...String(body.text || '').split(/\s+/).filter(Boolean)],
+        windows: ['search', '--onlyvisible', '--name', '.'],
+        focus: ['search', '--onlyvisible', '--name', String(body.title || ''), 'windowactivate'],
+      }[action];
+      const r = await runCapture(xdo, argvFor, { shell: false, timeout: 20000 });
+      if (action === 'windows') {
+        const ids = String(r.stdout || '').trim().split(/\s+/).filter(Boolean).slice(0, 40);
+        const titles = [];
+        for (const id of ids) {
+          const t = await runCapture(xdo, ['getwindowname', id], { shell: false, timeout: 5000 });
+          const title = String(t.stdout || '').trim();
+          if (title) titles.push({ title, id });
+        }
+        return { ok: true, windows: titles };
+      }
+      return r.code === 0 ? { ok: true, action } : { ok: false, error: String(r.stderr || '').trim() || `xdotool exited ${r.code}` };
+    }
+    case 'clipboard_get': {
+      const tool = firstExistingCommand(['wl-paste', 'xclip', 'xsel']);
+      if (!tool) return need('xclip', 'clipboard_get');
+      const argv = tool.name === 'xclip' ? ['-o', '-selection', 'clipboard'] : tool.name === 'xsel' ? ['-b', '-o'] : [];
+      const r = await runCapture(tool.bin, argv, { shell: false, timeout: 10000 });
+      return { ok: true, text: String(r.stdout || '') };
+    }
+    case 'clipboard_set': {
+      const tool = firstExistingCommand(['wl-copy', 'xclip', 'xsel']);
+      if (!tool) return need('xclip', 'clipboard_set');
+      const argv = tool.name === 'xclip' ? ['-selection', 'clipboard'] : tool.name === 'xsel' ? ['-b', '-i'] : [];
+      const r = await runCapture(tool.bin, argv, { shell: false, timeout: 10000, input: String(body.text || '') });
+      return r.code === 0 ? { ok: true, length: String(body.text || '').length } : { ok: false, error: `${tool.name} failed` };
+    }
+    default:
+      return { ok: false, error: `unsupported on Linux: ${action}` };
+  }
+}
+
+async function runHostUi(projectDir, body = {}) {
+  const action = String(body.action || '').trim();
+  if (!HOST_UI_ACTIONS.has(action)) {
+    return { status: 400, payload: { ok: false, error: `unknown action: ${action || '(none)'}`, actions: [...HOST_UI_ACTIONS] } };
+  }
+  const shot = action === 'screenshot' ? await hostUiScreenshotTarget(projectDir) : null;
+  let result;
+  try {
+    if (process.platform === 'win32') result = await runHostUiWindows(projectDir, action, body, shot);
+    else if (process.platform === 'darwin') result = await runHostUiMac(action, body, shot);
+    else result = await runHostUiLinux(action, body, shot);
+  } catch (err) {
+    result = { ok: false, error: err.message };
+  }
+  if (shot && result?.ok) {
+    // The project folder is bind-mounted into the container, so hand back the path the bot can
+    // actually open — otherwise it gets a Windows path it cannot read and reports failure.
+    result.path = shot.hostPath;
+    result.containerPath = shot.containerPath;
+    result.bytes = existsSync(shot.hostPath) ? (await fsp.stat(shot.hostPath)).size : 0;
+  }
+  sendLog(`[host-control] UI "${action}" → ${result?.ok ? 'ok' : `lỗi: ${result?.error || 'unknown'}`}`);
+  return { status: result?.ok ? 200 : 500, payload: result };
+}
+
 async function handleHostControl(req, res, projectDir) {
   const cfg = await readHostControlConfig(projectDir);
   const url = new URL(req.url, 'http://localhost');
@@ -3539,6 +4181,16 @@ async function handleHostControl(req, res, projectDir) {
   if (url.pathname === '/api/host/apps' && req.method === 'GET') {
     return json(res, { ok: true, apps: Object.keys(cfg.apps || {}), commands: Object.keys(cfg.commands || {}), platform: process.platform });
   }
+  if (url.pathname === '/api/host/ui' && req.method === 'POST') {
+    // Part of PC control, but its own switch: seeing the screen and moving the pointer is a bigger
+    // step than opening an app, so it only answers once the operator has granted capabilities.
+    if (cfg.ui !== true) {
+      return json(res, { ok: false, error: 'desktop actions are not granted. Ask the operator to press "Điều khiển máy" again in the dashboard (that writes ui:true).' }, 403);
+    }
+    const body = await readJson(req).catch(() => ({}));
+    const { status, payload } = await runHostUi(projectDir, body || {});
+    return json(res, payload, status);
+  }
   if (url.pathname === '/api/host/exec' && req.method === 'POST') {
     const body = await readJson(req).catch(() => ({}));
     const name = String(body.command || '').trim().toLowerCase();
@@ -3606,6 +4258,39 @@ async function writeHostControlAccess(projectDir, cfg) {
     '',
     `Lệnh khả dụng: ${commands.map((c) => `\`${c}\``).join(', ')}. Lệnh mặc định timeout 180s, output tối đa ~200KB/luồng.`,
   ] : [];
+  // Desktop actions: one endpoint, same JSON on every OS, so the bot does not need per-platform
+  // instructions. Screenshots land in the project folder, which the container already sees.
+  const uiBlock = cfg.ui === true ? [
+    '',
+    '### Thao tác trên màn hình chủ',
+    '',
+    'Một endpoint duy nhất cho mọi hệ điều hành. Cách làm đúng: **chụp màn hình trước, xem toạ độ, rồi mới click** —',
+    'đừng đoán vị trí. Toạ độ tính bằng pixel màn hình, gốc ở góc trên-trái.',
+    '',
+    '```sh',
+    `curl -s -X POST ${base}/api/host/ui -H "x-openclaw-token: ${cfg.token}" \\`,
+    '  -H "content-type: application/json" -d \'{"action":"screenshot"}\'',
+    '```',
+    '',
+    'Trả về `containerPath` — **đọc/gửi ảnh bằng đường dẫn đó** (nằm trong project nên bạn thấy được),',
+    'kèm `width`/`height` để biết màn hình bao lớn.',
+    '',
+    'Các action khác (cùng dạng `{"action":...}`):',
+    '',
+    '- `screen_size` — kích thước màn hình',
+    '- `mouse_move` + `x`,`y` — di chuột',
+    '- `click` + `x`,`y`, tuỳ chọn `button` (`left`/`right`/`middle`) và `clicks` (2 = double-click)',
+    '- `drag` + `x`,`y`,`toX`,`toY` — kéo thả',
+    '- `scroll` + `amount` (âm = xuống), tuỳ chọn `x`,`y`',
+    '- `type` + `text` — gõ chữ vào cửa sổ đang focus',
+    '- `key` + `text` — nhấn tổ hợp, ví dụ `"ctrl+c"`, `"enter"`, `"alt+tab"`; nhiều tổ hợp thì cách nhau bằng space',
+    '- `clipboard_get` / `clipboard_set` + `text` — đọc/ghi clipboard',
+    '- `windows` — liệt kê cửa sổ đang mở; `focus` + `title` — đưa cửa sổ lên trước',
+    '',
+    'Nếu trả về lỗi "no desktop session available" thì installer đang chạy ngoài phiên desktop —',
+    'nói chủ mở lại installer trong máy, đừng thử cách khác.',
+    'Trên Linux, thiếu `xdotool`/`scrot` thì endpoint nói rõ cần cài gì — báo lại cho chủ.',
+  ] : [];
   // Screen capture / recording — only advertised when the operator granted the matching tool, so
   // the bot never tries a binary that is not on this machine's allow-list.
   // Windows has no capture binary to allow-list (PowerShell does it inline), so the section shows
@@ -3712,6 +4397,7 @@ async function writeHostControlAccess(projectDir, cfg) {
     '',
     apps.length ? `App khả dụng trên máy này: ${apps.map((a) => `\`${a}\``).join(', ')}.` : 'Máy này chưa khai báo app nào — nhờ chủ thêm vào `.openclaw/host-control.json`.',
     ...execBlock,
+    ...uiBlock,
     // Docker only: a screenshot taken on the host lands on the HOST filesystem, which this
     // container cannot read — say so instead of letting the bot hunt for a missing file.
     ...(hasCapture ? [
@@ -3817,7 +4503,8 @@ async function ensureChromeRelay() {
 // Launch real host Chrome in remote-debugging mode (port 9222) so the browser-automation plugin
 // can drive the user's actual Chrome (logged-in profile) instead of headless Chromium. The bot
 // reaches it via CDP (host.docker.internal:9222 from the container). Detached: keeps running after
-// this request. `--remote-allow-origins=*` is required by modern Chrome for cross-origin CDP.
+// this request. The debug port stays on loopback and no origin wildcard is passed — a Node CDP
+// client sends no Origin header, so the wildcard only widened who could drive the browser.
 // On a headless VPS there is no Chrome to open here — instead we start the bridge relay and hand
 // back copy-paste commands so the user runs Chrome on THEIR machine + a reverse SSH tunnel.
 // Where Chrome keeps the operator's own profile, per OS. Chrome must not already be running
@@ -3902,8 +4589,8 @@ async function startChromeDebug() {
       port: 9222,
       // Same dedicated profile directories the local button and the generated scripts use, so
       // an operator who has already run one of those keeps the session they signed in with.
-      chromeCmdMac: `"/Applications/Google Chrome.app/Contents/MacOS/Google Chrome" --remote-debugging-port=9222 --user-data-dir="$HOME/${CHROME_DEBUG_PROFILE_LEAF_MAC}" --profile-directory=Default --remote-allow-origins='*'`,
-      chromeCmdWin: `"C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe" --remote-debugging-port=9222 --user-data-dir="%LOCALAPPDATA%\\${CHROME_DEBUG_PROFILE_LEAF_WIN}" --profile-directory=Default --remote-allow-origins=*`,
+      chromeCmdMac: `"/Applications/Google Chrome.app/Contents/MacOS/Google Chrome" --remote-debugging-port=9222 --user-data-dir="$HOME/${CHROME_DEBUG_PROFILE_LEAF_MAC}" --profile-directory=Default --remote-debugging-address=127.0.0.1`,
+      chromeCmdWin: `"C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe" --remote-debugging-port=9222 --user-data-dir="%LOCALAPPDATA%\\${CHROME_DEBUG_PROFILE_LEAF_WIN}" --profile-directory=Default --remote-debugging-address=127.0.0.1`,
       tunnelCmd: `ssh -N -R 9222:127.0.0.1:9222 ${user}@${ip}`,
     };
   }
@@ -3922,12 +4609,20 @@ async function startChromeDebug() {
   // --enable-automation, so navigator.webdriver stays false and there is no banner.
   // Set OPENCLAW_CHROME_PROFILE_DIR to point somewhere else (anything but the default profile).
   const userDataDir = process.env.OPENCLAW_CHROME_PROFILE_DIR || debugChromeProfileDir();
-  await seedDebugChromeProfile(defaultChromeProfileDir(), userDataDir, sendLog);
+  // Only when the operator asked for their logins: the copy duplicates cookies and sessions into
+  // a second profile directory, which is not something to do on a button press by default.
+  if (process.env.OPENCLAW_CHROME_SEED_PROFILE === '1') {
+    await seedDebugChromeProfile(defaultChromeProfileDir(), userDataDir, sendLog);
+  } else if (!existsSync(join(userDataDir, 'Default'))) {
+    sendLog('[chrome] Mở Chrome với profile điều khiển trống — đăng nhập 1 lần trong cửa sổ vừa mở. Muốn dùng sẵn đăng nhập của Chrome thường thì đặt OPENCLAW_CHROME_SEED_PROFILE=1 (sẽ chép cookie/đăng nhập/lịch sử sang profile đó).');
+  }
   const args = [
     `--remote-debugging-port=${port}`,
+    // Loopback only, and no --remote-allow-origins=*: a Node CDP client sends no Origin header,
+    // so the wildcard only widened who could drive this browser.
+    '--remote-debugging-address=127.0.0.1',
     `--user-data-dir=${userDataDir}`,
     '--profile-directory=Default',
-    '--remote-allow-origins=*',
     '--no-first-run',
     '--no-default-browser-check',
   ];
@@ -4030,13 +4725,18 @@ async function installCore({ osChoice, mode, projectDir, gatewayPort = 18789, ro
   state.os = osChoice;
   state.startedAt = new Date().toISOString();
   try {
-    // Native runs on the host's own ports, so it must not land on the docker defaults: a machine
-    // often has a docker project (or an SSH tunnel to a remote bot) already holding 18789/20128.
+    // Native binds the host directly, so it needs ports nothing else holds — but only when something
+    // actually holds them. Ask the host rather than assuming: a fresh machine keeps openclaw's and
+    // 9router's real defaults, and a machine that already runs a docker project (or an SSH tunnel to
+    // a remote bot) steps to the next free pair instead.
     if (mode === 'native') {
-      if (gatewayPort === 18789) gatewayPort = NATIVE_DEFAULT_GATEWAY_PORT;
-      if (routerPort === 20128) routerPort = NATIVE_DEFAULT_ROUTER_PORT;
+      gatewayPort = await findFreeHostPort(gatewayPort, { reserveNext: true });
+      routerPort = await findFreeHostPort(routerPort);
       state.gatewayPort = gatewayPort;
       state.routerPort = routerPort;
+      state.gatewayUrl = `http://127.0.0.1:${gatewayPort}`;
+      state.routerUrl = `http://127.0.0.1:${routerPort}`;
+      sendLog(`[native] ports: gateway ${gatewayPort}, 9router ${routerPort}`);
     }
     sendLog('OpenClaw local installer started');
     sendLog(`Target: OS=${osChoice}, mode=${mode}, project=${projectDir}, gatewayPort=${gatewayPort}, routerPort=${routerPort}`);
@@ -4145,6 +4845,9 @@ async function listMarkdownFiles(projectDir, agentId = '') {
 }
 
 async function saveState(rootProjectDir) {
+  // Selecting, adding or removing a project all end up here, and all of them make the cached
+  // project list wrong — drop it so the next request rebuilds instead of showing the old set.
+  probeCacheClear('projects:');
   const file = join(rootProjectDir, STATE_FILE);
   await fsp.writeFile(file, JSON.stringify({
     projectDir: state.projectDir,
@@ -4226,6 +4929,9 @@ function isRestrictedSystemDir(dirPath) {
 // so a fresh `npx github:…` run (e.g. on a VPS where bots are already running) targets the
 // live project instead of defaulting to an empty ~/openclaw-setup folder.
 async function discoverDockerBotProjectRoots() {
+  const ck = 'dockerroots';
+  const cached = probeCacheGet(ck);
+  if (cached) return cached;
   const roots = [];
   try {
     const r = await runCapture(
@@ -4244,7 +4950,9 @@ async function discoverDockerBotProjectRoots() {
       }
     }
   } catch {}
-  return [...new Set(roots)];
+  const unique = [...new Set(roots)];
+  probeCacheSet(ck, unique, 15000);
+  return unique;
 }
 
 // Native installs have no container to inspect, so we can't detect them the way Docker bots are
@@ -4343,7 +5051,15 @@ async function ensureProjectsLoaded(rootProjectDir) {
   }
 }
 
-async function discoverProjects(rootProjectDir) {
+// The project list costs docker/native probes per project. It changes when someone creates or
+// deletes a project — not between two page loads — so serve it from a short cache and refresh in
+// the background: the dashboard opens instantly and is at most a few seconds stale.
+const PROJECTS_TTL_MS = 10000;
+function discoverProjects(rootProjectDir) {
+  return sharedProbe(`projects:${rootProjectDir || ''}`, PROJECTS_TTL_MS, () => computeDiscoverProjects(rootProjectDir));
+}
+
+async function computeDiscoverProjects(rootProjectDir) {
   await ensureProjectsLoaded(rootProjectDir);
 
   // Surface projects whose bot is running in Docker even if this install has no saved
@@ -4371,16 +5087,14 @@ async function discoverProjects(rootProjectDir) {
     }
   }
 
-  const updatedProjects = [];
-  for (const p of state.projects) {
-    if (existsSync(join(p.projectDir, '.openclaw', 'openclaw.json'))) {
-      const meta = await buildProjectMeta(p.projectDir).catch(() => null);
-      if (meta) {
-        updatedProjects.push(meta);
-      }
-    }
-  }
-  state.projects = updatedProjects;
+  // In parallel: each buildProjectMeta runs runtime detection (docker calls, port probes), so a
+  // handful of projects turned into seconds of dashboard load when this was a sequential loop.
+  const metas = await Promise.all(
+    state.projects
+      .filter((p) => existsSync(join(p.projectDir, '.openclaw', 'openclaw.json')))
+      .map((p) => buildProjectMeta(p.projectDir).catch(() => null)),
+  );
+  state.projects = metas.filter(Boolean);
   
   state.projects.sort((a, b) => {
     const aActive = state.projectDir && resolve(state.projectDir) === resolve(a.projectDir);
@@ -4969,6 +5683,11 @@ async function installFeature(projectDir, agentId, kind, id) {
         if (existingKey === 'browser-automation' || existingKey === 'openclaw-browser-automation') {
           cfg.plugins.entries[existingKey].config = Object.assign({}, cfg.plugins.entries[existingKey].config, {
             hostOs: await resolveProjectHostOs(projectDir),
+            // The plugin ships these off: editing the Docker build files, running page JavaScript
+            // and uploading local files are things it will not do until an operator says so.
+            // Installing it from this dashboard IS that operator saying so — otherwise browsing
+            // would need a hand-edited config right after a one-click install.
+            ...browserAutomationOptIns(),
           });
           cfg.tools = cfg.tools || { profile: 'full', exec: { host: 'gateway', security: 'full', ask: 'off' } };
           cfg.tools.alsoAllow = Array.from(new Set([...(cfg.tools.alsoAllow || []), 'group:web']));
@@ -5068,6 +5787,11 @@ async function installFeature(projectDir, agentId, kind, id) {
         if (existingKey === 'browser-automation' || existingKey === 'openclaw-browser-automation') {
           cfg.plugins.entries[existingKey].config = Object.assign({}, cfg.plugins.entries[existingKey].config, {
             hostOs: await resolveProjectHostOs(projectDir),
+            // The plugin ships these off: editing the Docker build files, running page JavaScript
+            // and uploading local files are things it will not do until an operator says so.
+            // Installing it from this dashboard IS that operator saying so — otherwise browsing
+            // would need a hand-edited config right after a one-click install.
+            ...browserAutomationOptIns(),
           });
           cfg.tools = cfg.tools || { profile: 'full', exec: { host: 'gateway', security: 'full', ask: 'off' } };
           cfg.tools.alsoAllow = Array.from(new Set([...(cfg.tools.alsoAllow || []), 'group:web']));
@@ -5923,6 +6647,15 @@ export async function startLocalInstaller({ host = '127.0.0.1', preferredPort =
   // Bring the host-control service back up when the operator left it enabled, so the bot's
   // saved instructions keep working across installer restarts.
   ensureHostControl(projectDir).catch(() => {});
-}
-
-export { patchBrowserAutomationHostPreference, debugChromeProfileDir, defaultChromeProfileDir, createBotInProject, updateBotInProject, deleteBotInProject, validateOpenclawConfig, startZaloLogin, readBotCredentials, resolveProject9RouterApiKey, installCore, deleteProjectFolder, buildZaloHealthSnapshot, removeEmptyWorkspaceAttestations, runHostCommand, detectHostCommands, detectHostCapabilityCommands, grantHostCapabilities, detectCodexApp, detectCodexMarketplace, resolveCodexCli, openPrivacyPane, projectDeployMode, isNativeProject, nativeServiceLabel, nativeEnv, ocArgv, migrateNativePaths, discoverNativeProjectRoots };
+  // Warm the probes the first page load would otherwise wait on (project list, runtime versions,
+  // public IP, Zalo status). They run while the browser is still starting, so the dashboard opens
+  // against a warm cache instead of paying for docker and CLI round-trips on first paint.
+  Promise.all([
+    discoverProjects(projectDir).catch(() => {}),
+    getCurrentRuntimeVersions().catch(() => {}),
+    getPublicIp().catch(() => {}),
+    existsSync(join(projectDir, '.openclaw', 'openclaw.json')) ? getZaloHealth(projectDir).catch(() => {}) : null,
+  ]).catch(() => {});
+}
+
+export { patchBrowserAutomationHostPreference, debugChromeProfileDir, defaultChromeProfileDir, createBotInProject, updateBotInProject, deleteBotInProject, validateOpenclawConfig, startZaloLogin, readBotCredentials, resolveProject9RouterApiKey, installCore, deleteProjectFolder, buildZaloHealthSnapshot, removeEmptyWorkspaceAttestations, runHostCommand, detectHostCommands, detectHostCapabilityCommands, grantHostCapabilities, detectCodexApp, detectCodexMarketplace, resolveCodexCli, openPrivacyPane, projectDeployMode, isNativeProject, nativeServiceLabel, nativeEnv, ocArgv, migrateNativePaths, discoverNativeProjectRoots, detectOs, stripCliWarnings, migrationLeaseDeadline, ensureNativePlugins, findFreeHostPort };