@teamclaws/teamclaw 2026.3.25 → 2026.3.26-2

package/cli.mjs

@@ -1,14 +1,22 @@
 #!/usr/bin/env node
 
 import { spawnSync } from "node:child_process";
+import fsSync from "node:fs";
 import fs from "node:fs/promises";
+import http from "node:http";
+import { createRequire } from "node:module";
 import os from "node:os";
 import path from "node:path";
 import process from "node:process";
 import { createInterface } from "node:readline/promises";
 import JSON5 from "json5";
 
-const PACKAGE_NAME = "@teamclaws/teamclaw";
+const require = createRequire(import.meta.url);
+const packageMetadata = require("./package.json");
+const PACKAGE_ROOT = path.dirname(require.resolve("./package.json"));
+const PACKAGE_NAME = packageMetadata.name;
+const PACKAGE_VERSION = packageMetadata.version;
+const PACKAGE_INSTALL_SPEC = `${PACKAGE_NAME}@${PACKAGE_VERSION}`;
 const PLUGIN_ID = "teamclaw";
 const DEFAULT_TEAMCLAW_IMAGE = "ghcr.io/topcheer/teamclaw-openclaw:latest";
 const DEFAULT_CONTROLLER_PORT = 9527;
@@ -18,7 +26,7 @@ const DEFAULT_TEAM_NAME = "default";
 const DEFAULT_TASK_TIMEOUT_MS = 1_800_000;
 const DEFAULT_AGENT_TIMEOUT_SECONDS = 2_400;
 const DEFAULT_LOCAL_ROLES = ["architect", "developer", "qa"];
-const DEFAULT_PROVISIONING_ROLES = ["architect", "developer", "qa"];
+const LEGACY_DEFAULT_PROVISIONING_ROLES = ["architect", "developer", "qa"];
 
 const ROLE_OPTIONS = [
   { value: "pm", label: "Product Manager" },
@@ -182,6 +190,30 @@ function resolveDefaultOpenClawWorkspaceDir(env = process.env) {
   return path.join(resolveDefaultOpenClawStateDir(env), "workspace");
 }
 
+function resolveOpenClawStateDirForConfigPath(configPath) {
+  return path.dirname(path.resolve(configPath));
+}
+
+function resolveOpenClawWorkspaceDirForConfigPath(configPath) {
+  return path.join(resolveOpenClawStateDirForConfigPath(configPath), "workspace");
+}
+
+function sanitizeInstallerPathSegment(value) {
+  const normalized = String(value || "")
+    .toLowerCase()
+    .replace(/[^a-z0-9-]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+  return normalized || "default";
+}
+
+function resolveDefaultTeamClawWorkspaceDir(configPath, teamName) {
+  return path.join(
+    resolveOpenClawStateDirForConfigPath(configPath),
+    "teamclaw-workspaces",
+    sanitizeInstallerPathSegment(teamName),
+  );
+}
+
 async function pathExists(targetPath) {
   try {
     await fs.access(targetPath);
@@ -302,10 +334,40 @@ function getCurrentWorkspacePath(config) {
   return typeof defaults.workspace === "string" ? expandUserPath(defaults.workspace) : "";
 }
 
+function resolveInstallerWorkspaceDefault(configPath, config, teamName) {
+  const currentWorkspacePath = getCurrentWorkspacePath(config);
+  const sharedWorkspacePath = resolveOpenClawWorkspaceDirForConfigPath(configPath);
+  if (currentWorkspacePath && path.resolve(currentWorkspacePath) !== path.resolve(sharedWorkspacePath)) {
+    return currentWorkspacePath;
+  }
+  return resolveDefaultTeamClawWorkspaceDir(configPath, teamName);
+}
+
 function dedupeStrings(values) {
   return Array.from(new Set(values.filter((value) => typeof value === "string" && value.trim()).map((value) => value.trim())));
 }
 
+function hasSameStringSet(left, right) {
+  const normalizedLeft = dedupeStrings(left).slice().sort();
+  const normalizedRight = dedupeStrings(right).slice().sort();
+  if (normalizedLeft.length !== normalizedRight.length) {
+    return false;
+  }
+  return normalizedLeft.every((value, index) => value === normalizedRight[index]);
+}
+
+function normalizeConfiguredRoleList(raw) {
+  return Array.isArray(raw) ? dedupeStrings(raw) : [];
+}
+
+function resolveDefaultProvisioningRoles(existingTeamClaw) {
+  const existingRoles = normalizeConfiguredRoleList(existingTeamClaw.workerProvisioningRoles);
+  if (existingRoles.length === 0) {
+    return [];
+  }
+  return hasSameStringSet(existingRoles, LEGACY_DEFAULT_PROVISIONING_ROLES) ? [] : existingRoles;
+}
+
 function extractModelOptions(config) {
   const currentModel = getCurrentModel(config);
   const models = [];
@@ -512,6 +574,28 @@ async function promptRoleList(prompter, message, defaultRoles) {
   return parseRoleList(raw).values;
 }
 
+async function promptOptionalRoleList(prompter, message, defaultRoles) {
+  const defaultValue = defaultRoles.join(",");
+  if (!prompter.yes) {
+    console.log(
+      `Available roles: ${ROLE_OPTIONS.map((option) => `${option.value} (${option.label})`).join(", ")}. These are preferred defaults only; task-required roles can still launch automatically.`,
+    );
+  }
+  const raw = await prompter.text({
+    message,
+    defaultValue,
+    allowEmpty: true,
+    validate: (value) => {
+      const parsed = parseRoleList(value);
+      if (parsed.invalid.length > 0) {
+        return `Unknown role ids: ${parsed.invalid.join(", ")}`;
+      }
+      return "";
+    },
+  });
+  return parseRoleList(raw).values;
+}
+
 function buildStartCommand(configPath) {
   const defaultPath = resolveDefaultOpenClawConfigPath();
   if (path.resolve(configPath) === path.resolve(defaultPath)) {
@@ -527,6 +611,57 @@ function shellEscape(value) {
   return `'${String(value).replace(/'/g, `'\\''`)}'`;
 }
 
+function isControllerInstallMode(installMode) {
+  return installMode !== "worker";
+}
+
+function isOnDemandControllerInstallMode(installMode) {
+  return installMode === "controller-process" || installMode === "controller-docker" || installMode === "controller-kubernetes";
+}
+
+function describeProvisioningRoles(roles) {
+  return Array.isArray(roles) && roles.length > 0
+    ? `${roles.join(", ")} (plus any task-required roles)`
+    : "all TeamClaw roles (controller decides at runtime)";
+}
+
+function getLocalUiUrl(port) {
+  return `http://127.0.0.1:${port}/ui`;
+}
+
+function rankLanAddress(address) {
+  if (address.startsWith("192.168.")) {
+    return 0;
+  }
+  if (address.startsWith("10.")) {
+    return 1;
+  }
+  const parts = address.split(".").map((value) => Number.parseInt(value, 10));
+  if (parts.length === 4 && parts[0] === 172 && parts[1] >= 16 && parts[1] <= 31) {
+    return 2;
+  }
+  return 3;
+}
+
+function listLanUiUrls(port) {
+  const urls = [];
+  const interfaces = os.networkInterfaces();
+  for (const records of Object.values(interfaces)) {
+    for (const record of records ?? []) {
+      if (!record || record.internal || record.family !== "IPv4") {
+        continue;
+      }
+      urls.push({
+        address: record.address,
+        url: `http://${record.address}:${port}/ui`,
+      });
+    }
+  }
+  return urls
+    .sort((left, right) => rankLanAddress(left.address) - rankLanAddress(right.address) || left.address.localeCompare(right.address))
+    .map((entry) => entry.url);
+}
+
 function installPluginWithCommand(command, args, env) {
   const result = spawnSync(command, args, {
     stdio: "inherit",
@@ -539,7 +674,96 @@ function installPluginWithCommand(command, args, env) {
   };
 }
 
-function attemptPluginInstall({ configPath }) {
+function runGatewayCommand(command, args, env) {
+  const result = spawnSync(command, args, {
+    env,
+    encoding: "utf8",
+  });
+  return {
+    status: result.status ?? 1,
+    signal: result.signal ?? null,
+    error: result.error ?? null,
+    stdout: result.stdout ?? "",
+    stderr: result.stderr ?? "",
+  };
+}
+
+function readJsonIfExists(filePath) {
+  try {
+    if (!fsSync.existsSync(filePath)) {
+      return null;
+    }
+    return JSON.parse(fsSync.readFileSync(filePath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function inspectInstalledPlugin(configPath) {
+  const stateDir = path.dirname(path.resolve(configPath));
+  const pluginDir = path.join(stateDir, "extensions", PLUGIN_ID);
+  if (!fsSync.existsSync(pluginDir)) {
+    return null;
+  }
+  const manifest = readJsonIfExists(path.join(pluginDir, "openclaw.plugin.json"));
+  const packageJson = readJsonIfExists(path.join(pluginDir, "package.json"));
+  const version = typeof manifest?.version === "string" && manifest.version.trim()
+    ? manifest.version.trim()
+    : typeof packageJson?.version === "string" && packageJson.version.trim()
+      ? packageJson.version.trim()
+      : "";
+  return {
+    pluginDir,
+    version: version || null,
+  };
+}
+
+function createPackageTarball(env) {
+  let tempDir = "";
+  try {
+    tempDir = fsSync.mkdtempSync(path.join(os.tmpdir(), "teamclaw-installer-pack-"));
+    const result = spawnSync(
+      "npm",
+      ["pack", PACKAGE_ROOT, "--pack-destination", tempDir, "--json", "--ignore-scripts"],
+      {
+        env,
+        encoding: "utf8",
+      },
+    );
+    if (result.status !== 0 || result.error) {
+      const detail = result.error
+        ? result.error.message
+        : (result.stderr || result.stdout || `exited with code ${result.status}`).trim();
+      throw new Error(detail || "npm pack failed");
+    }
+    const payload = JSON.parse(result.stdout);
+    const filename = Array.isArray(payload) && payload[0] && typeof payload[0].filename === "string"
+      ? payload[0].filename.trim()
+      : "";
+    if (!filename) {
+      throw new Error("npm pack did not report a tarball filename");
+    }
+    const tarballPath = path.join(tempDir, filename);
+    if (!fsSync.existsSync(tarballPath)) {
+      throw new Error(`tarball was not created at ${tarballPath}`);
+    }
+    return {
+      ok: true,
+      tempDir,
+      tarballPath,
+    };
+  } catch (error) {
+    if (tempDir) {
+      fsSync.rmSync(tempDir, { recursive: true, force: true });
+    }
+    return {
+      ok: false,
+      error: error instanceof Error ? error.message : String(error),
+    };
+  }
+}
+
+function attemptPluginUninstall({ configPath }) {
   const env = {
     ...process.env,
     OPENCLAW_CONFIG_PATH: configPath,
@@ -548,18 +772,18 @@ function attemptPluginInstall({ configPath }) {
     {
       label: "openclaw",
       command: "openclaw",
-      args: ["plugins", "install", PACKAGE_NAME],
+      args: ["plugins", "uninstall", PLUGIN_ID, "--force"],
     },
     {
       label: "npm exec fallback",
       command: "npm",
-      args: ["exec", "-y", "openclaw@latest", "--", "plugins", "install", PACKAGE_NAME],
+      args: ["exec", "-y", "openclaw@latest", "--", "plugins", "uninstall", PLUGIN_ID, "--force"],
     },
   ];
-
+  const failures = [];
   for (let index = 0; index < candidates.length; index += 1) {
     const candidate = candidates[index];
-    console.log(`\nInstalling ${PACKAGE_NAME} with ${candidate.label}...`);
+    console.log(`\nRemoving existing ${PLUGIN_ID} plugin with ${candidate.label}...`);
     const result = installPluginWithCommand(candidate.command, candidate.args, env);
     if (result.status === 0 && !result.error) {
       return {
@@ -568,31 +792,252 @@ function attemptPluginInstall({ configPath }) {
       };
     }
     const errorCode = result.error && typeof result.error === "object" ? result.error.code : "";
-    if (errorCode === "ENOENT" && index < candidates.length - 1) {
-      console.log(`${candidate.command} was not found. Trying the npm exec fallback...`);
-      continue;
-    }
     const detail = result.error
       ? result.error.message
       : result.signal
         ? `terminated by signal ${result.signal}`
         : `exited with code ${result.status}`;
+    failures.push(`${candidate.label} failed: ${detail}`);
+    if (errorCode === "ENOENT" && index < candidates.length - 1) {
+      console.log(`${candidate.command} was not found. Trying the next uninstall fallback...`);
+      continue;
+    }
+    break;
+  }
+  return {
+    ok: false,
+    error: failures.join("; "),
+  };
+}
+
+function attemptPluginInstall({ configPath }) {
+  const env = {
+    ...process.env,
+    OPENCLAW_CONFIG_PATH: configPath,
+  };
+  const installedPlugin = inspectInstalledPlugin(configPath);
+  if (installedPlugin?.version === PACKAGE_VERSION) {
+    console.log(
+      `\nFound existing TeamClaw plugin at ${installedPlugin.pluginDir} (version ${installedPlugin.version}). Skipping plugin reinstall.`,
+    );
+    return {
+      ok: true,
+      method: `already installed (${installedPlugin.version})`,
+      skipped: true,
+    };
+  }
+  if (installedPlugin) {
+    const installedVersion = installedPlugin.version ? `version ${installedPlugin.version}` : "an unknown version";
+    console.log(
+      `\nFound existing TeamClaw plugin at ${installedPlugin.pluginDir} (${installedVersion}). Removing it before install...`,
+    );
+    const uninstallResult = attemptPluginUninstall({ configPath });
+    if (!uninstallResult.ok) {
+      return {
+        ok: false,
+        error: `Could not remove existing TeamClaw plugin at ${installedPlugin.pluginDir}: ${uninstallResult.error}`,
+      };
+    }
+  }
+  const candidates = [];
+  const tarballResult = createPackageTarball(env);
+  if (tarballResult.ok) {
+    console.log(
+      `\nPacked ${PACKAGE_INSTALL_SPEC} into ${path.basename(tarballResult.tarballPath)} for local plugin install.`,
+    );
+    candidates.push(
+      {
+        label: "openclaw (local tarball)",
+        command: "openclaw",
+        args: ["plugins", "install", tarballResult.tarballPath],
+        targetDescription: tarballResult.tarballPath,
+      },
+      {
+        label: "npm exec fallback (local tarball)",
+        command: "npm",
+        args: ["exec", "-y", "openclaw@latest", "--", "plugins", "install", tarballResult.tarballPath],
+        targetDescription: tarballResult.tarballPath,
+      },
+    );
+  } else {
+    console.log(
+      `\nCould not pack ${PACKAGE_INSTALL_SPEC} into a local tarball (${tarballResult.error}). Falling back to registry install...`,
+    );
+  }
+  candidates.push(
+    {
+      label: "openclaw (exact version fallback)",
+      command: "openclaw",
+      args: ["plugins", "install", PACKAGE_INSTALL_SPEC],
+      targetDescription: PACKAGE_INSTALL_SPEC,
+    },
+    {
+      label: "npm exec fallback (exact version fallback)",
+      command: "npm",
+      args: ["exec", "-y", "openclaw@latest", "--", "plugins", "install", PACKAGE_INSTALL_SPEC],
+      targetDescription: PACKAGE_INSTALL_SPEC,
+    },
+  );
+
+  try {
+    const failures = [];
+    for (let index = 0; index < candidates.length; index += 1) {
+      const candidate = candidates[index];
+      console.log(`\nInstalling ${candidate.targetDescription} with ${candidate.label}...`);
+      const result = installPluginWithCommand(candidate.command, candidate.args, env);
+      if (result.status === 0 && !result.error) {
+        return {
+          ok: true,
+          method: candidate.label,
+        };
+      }
+      const errorCode = result.error && typeof result.error === "object" ? result.error.code : "";
+      const detail = result.error
+        ? result.error.message
+        : result.signal
+          ? `terminated by signal ${result.signal}`
+          : `exited with code ${result.status}`;
+      failures.push(`${candidate.label} failed: ${detail}`);
+      if (errorCode === "ENOENT" && index < candidates.length - 1) {
+        console.log(`${candidate.command} was not found. Trying the next install fallback...`);
+        continue;
+      }
+      if (index < candidates.length - 1) {
+        console.log(`${candidate.label} failed (${detail}). Trying the next install fallback...`);
+      }
+    }
     return {
       ok: false,
-      error: `${candidate.label} failed: ${detail}`,
+      error: failures.length > 0 ? failures.join("; ") : "No install command was available.",
     };
+  } finally {
+    if (tarballResult.ok) {
+      fsSync.rmSync(tarballResult.tempDir, { recursive: true, force: true });
+    }
   }
+}
 
+function attemptGatewayRestart({ configPath }) {
+  const env = {
+    ...process.env,
+    OPENCLAW_CONFIG_PATH: configPath,
+  };
+  const candidates = [
+    {
+      label: "openclaw",
+      command: "openclaw",
+      args: ["gateway", "restart"],
+    },
+    {
+      label: "npm exec fallback",
+      command: "npm",
+      args: ["exec", "-y", "openclaw@latest", "--", "gateway", "restart"],
+    },
+  ];
+  const failures = [];
+  for (let index = 0; index < candidates.length; index += 1) {
+    const candidate = candidates[index];
+    const result = runGatewayCommand(candidate.command, candidate.args, env);
+    if (result.status === 0 && !result.error) {
+      return {
+        ok: true,
+        method: candidate.label,
+      };
+    }
+    const detail = result.error
+      ? result.error.message
+      : (result.stderr || result.stdout || (result.signal
+          ? `terminated by signal ${result.signal}`
+          : `exited with code ${result.status}`)).trim();
+    failures.push(`${candidate.label} failed: ${detail}`);
+    const errorCode = result.error && typeof result.error === "object" ? result.error.code : "";
+    if (!(errorCode === "ENOENT" && index < candidates.length - 1)) {
+      break;
+    }
+  }
   return {
     ok: false,
-    error: "No install command was available.",
+    error: failures.join("; "),
   };
 }
 
-async function collectInstallChoices(config, prompter) {
+async function waitForControllerHealth(port) {
+  const url = `http://127.0.0.1:${port}/api/v1/health`;
+  const deadline = Date.now() + 30_000;
+  let lastError = "";
+  while (Date.now() < deadline) {
+    try {
+      const response = await new Promise((resolve, reject) => {
+        const request = http.get(
+          url,
+          {
+            agent: false,
+            headers: {
+              Connection: "close",
+            },
+          },
+          (incoming) => {
+            let body = "";
+            incoming.setEncoding("utf8");
+            incoming.on("data", (chunk) => {
+              body += chunk;
+            });
+            incoming.on("end", () => {
+              resolve({
+                statusCode: incoming.statusCode ?? 0,
+                body,
+              });
+            });
+          },
+        );
+        request.setTimeout(5_000, () => {
+          request.destroy(new Error("request timed out"));
+        });
+        request.on("error", reject);
+      });
+      if (response.statusCode >= 200 && response.statusCode < 300) {
+        const payload = JSON.parse(response.body);
+        if (payload && payload.status === "ok" && payload.mode === "controller") {
+          return {
+            ok: true,
+            url,
+          };
+        }
+        lastError = "unexpected health payload";
+      } else {
+        lastError = `HTTP ${response.statusCode}`;
+      }
+    } catch (error) {
+      lastError = error instanceof Error ? error.message : String(error);
+    }
+    await new Promise((resolve) => setTimeout(resolve, 1_000));
+  }
+  return {
+    ok: false,
+    url,
+    error: lastError || "timed out after 30s",
+  };
+}
+
+async function collectInstallChoices(configPath, config, prompter) {
   const existingTeamClaw = getExistingTeamClawConfig(config);
   const existingMode = typeof existingTeamClaw.mode === "string" ? existingTeamClaw.mode.trim() : "";
-  const modeDefault = existingMode === "worker" ? "worker" : "single-local";
+  const existingProvisioningType =
+    typeof existingTeamClaw.workerProvisioningType === "string" ? existingTeamClaw.workerProvisioningType.trim() : "";
+  let modeDefault = "single-local";
+  if (existingMode === "worker") {
+    modeDefault = "worker";
+  } else if (existingMode === "controller") {
+    if (existingProvisioningType === "docker") {
+      modeDefault = "controller-docker";
+    } else if (existingProvisioningType === "kubernetes") {
+      modeDefault = "controller-kubernetes";
+    } else if (existingProvisioningType === "process") {
+      modeDefault = "controller-process";
+    } else if (!Array.isArray(existingTeamClaw.localRoles) || existingTeamClaw.localRoles.length === 0) {
+      modeDefault = "controller-manual";
+    }
+  }
 
   const installMode = await prompter.select({
     message: "Choose an installation mode",
@@ -625,7 +1070,7 @@ async function collectInstallChoices(config, prompter) {
   });
   const workspacePath = expandUserPath(await prompter.text({
     message: "OpenClaw workspace directory",
-    defaultValue: getCurrentWorkspacePath(config) || resolveDefaultOpenClawWorkspaceDir(),
+    defaultValue: resolveInstallerWorkspaceDefault(configPath, config, teamName),
   }));
 
   if (installMode === "worker") {
@@ -705,12 +1150,10 @@ async function collectInstallChoices(config, prompter) {
     };
   }
 
-  const provisioningRoles = await promptRoleList(
+  const provisioningRoles = await promptOptionalRoleList(
     prompter,
-    "On-demand roles to launch (comma-separated)",
-    Array.isArray(existingTeamClaw.workerProvisioningRoles) && existingTeamClaw.workerProvisioningRoles.length > 0
-      ? existingTeamClaw.workerProvisioningRoles
-      : DEFAULT_PROVISIONING_ROLES,
+    "Preferred on-demand roles (comma-separated, leave empty for controller-decided defaults)",
+    resolveDefaultProvisioningRoles(existingTeamClaw),
   );
   const maxPerRole = await prompter.number({
     message: "Maximum on-demand workers per role",
@@ -753,11 +1196,11 @@ async function collectInstallChoices(config, prompter) {
           : DEFAULT_TEAMCLAW_IMAGE,
     });
     const dockerWorkspaceVolume = await prompter.text({
-      message: "Docker workspace volume or host path (leave empty for ephemeral workspaces)",
+      message: "Docker workspace volume or host path (leave empty for isolated ephemeral workspaces)",
       defaultValue:
         typeof existingTeamClaw.workerProvisioningDockerWorkspaceVolume === "string"
           ? existingTeamClaw.workerProvisioningDockerWorkspaceVolume.trim()
-          : "teamclaw-workspaces",
+          : "",
       allowEmpty: true,
     });
     return {
@@ -808,7 +1251,7 @@ async function collectInstallChoices(config, prompter) {
         : "teamclaw-worker",
   });
   const kubernetesWorkspacePersistentVolumeClaim = await prompter.text({
-    message: "Kubernetes workspace PVC (leave empty for ephemeral workspaces)",
+    message: "Kubernetes workspace PVC (leave empty for isolated ephemeral workspaces)",
     defaultValue:
       typeof existingTeamClaw.workerProvisioningKubernetesWorkspacePersistentVolumeClaim === "string"
         ? existingTeamClaw.workerProvisioningKubernetesWorkspacePersistentVolumeClaim.trim()
@@ -1048,19 +1491,38 @@ function buildSummaryLines(params) {
   }
   if (params.pluginInstallStatus === "installed") {
     lines.push(`Plugin install: completed via ${params.pluginInstallMethod}`);
+  } else if (params.pluginInstallStatus === "already-installed") {
+    lines.push(`Plugin install: ${params.pluginInstallMethod}`);
   } else if (params.pluginInstallStatus === "skipped") {
     lines.push("Plugin install: skipped");
   } else if (params.pluginInstallError) {
     lines.push(`Plugin install: ${params.pluginInstallError}`);
   }
+  if (params.gatewayRestartStatus === "restarted") {
+    lines.push(`Gateway restart: completed via ${params.gatewayRestartMethod}`);
+  } else if (params.gatewayRestartStatus === "failed") {
+    lines.push(`Gateway restart: ${params.gatewayRestartError}`);
+  }
+  if (params.controllerHealthStatus === "ok") {
+    lines.push(`Controller health: ok (${params.controllerHealthUrl})`);
+  } else if (params.controllerHealthStatus === "failed") {
+    lines.push(`Controller health: ${params.controllerHealthError} (${params.controllerHealthUrl})`);
+  }
   lines.push(`Start command: ${buildStartCommand(params.configPath)}`);
 
-  if (params.choices.installMode === "single-local") {
-    lines.push(`Open UI: http://127.0.0.1:${params.choices.controllerPort}/ui`);
+  if (isControllerInstallMode(params.choices.installMode)) {
+    const lanUiUrls = listLanUiUrls(params.choices.controllerPort);
+    if (lanUiUrls.length > 0) {
+      lines.push(`Open UI (LAN): ${lanUiUrls[0]}`);
+    }
+    lines.push(`Open UI (local): ${getLocalUiUrl(params.choices.controllerPort)}`);
   }
   if (params.choices.installMode === "controller-docker" || params.choices.installMode === "controller-kubernetes") {
     lines.push(`Provisioning image: ${params.choices.workerImage}`);
   }
+  if (isOnDemandControllerInstallMode(params.choices.installMode)) {
+    lines.push(`On-demand roles: ${describeProvisioningRoles(params.choices.provisioningRoles)}`);
+  }
   if (params.choices.installMode === "controller-docker" && params.choices.dockerWorkspaceVolume) {
     lines.push(`Docker workspace volume: ${params.choices.dockerWorkspaceVolume}`);
   }
@@ -1112,7 +1574,7 @@ async function runInstall(options) {
     if (!options.skipPluginInstall && !options.dryRun) {
       const installResult = attemptPluginInstall({ configPath });
       if (installResult.ok) {
-        pluginInstallStatus = "installed";
+        pluginInstallStatus = installResult.skipped ? "already-installed" : "installed";
         pluginInstallMethod = installResult.method;
       } else {
         pluginInstallStatus = "failed";
@@ -1129,7 +1591,7 @@ async function runInstall(options) {
     }
 
     const config = await readOpenClawConfig(configPath);
-    const choices = await collectInstallChoices(config, prompter);
+    const choices = await collectInstallChoices(configPath, config, prompter);
     const nextConfig = applyInstallerChoices(config, choices);
 
     if (options.dryRun) {
@@ -1138,6 +1600,29 @@ async function runInstall(options) {
       await writeConfig(configPath, nextConfig);
     }
 
+    let gatewayRestartStatus = "skipped";
+    let gatewayRestartMethod = "";
+    let gatewayRestartError = "";
+    let controllerHealthStatus = "skipped";
+    let controllerHealthUrl = "";
+    let controllerHealthError = "";
+    if (!options.dryRun) {
+      const restartResult = attemptGatewayRestart({ configPath });
+      if (restartResult.ok) {
+        gatewayRestartStatus = "restarted";
+        gatewayRestartMethod = restartResult.method;
+        if (isControllerInstallMode(choices.installMode)) {
+          const healthResult = await waitForControllerHealth(choices.controllerPort);
+          controllerHealthStatus = healthResult.ok ? "ok" : "failed";
+          controllerHealthUrl = healthResult.url;
+          controllerHealthError = healthResult.error ?? "";
+        }
+      } else {
+        gatewayRestartStatus = "failed";
+        gatewayRestartError = restartResult.error;
+      }
+    }
+
     const summaryLines = buildSummaryLines({
       configPath,
       choices,
@@ -1145,6 +1630,12 @@ async function runInstall(options) {
       pluginInstallStatus,
       pluginInstallMethod,
       pluginInstallError,
+      gatewayRestartStatus,
+      gatewayRestartMethod,
+      gatewayRestartError,
+      controllerHealthStatus,
+      controllerHealthUrl,
+      controllerHealthError,
     });
 
     prompter.note("\nTeamClaw installer summary");