@p697/clawket 0.4.5 → 0.5.0

package/dist/index.js

@@ -1133,10 +1133,11 @@ function resolveGatewayUrl(explicitUrl) {
 }
 function readOpenClawInfo() {
   const openclaw = resolveOpenClawPaths();
+  const envGatewayPort = readGatewayPortEnv();
   if (!existsSync3(openclaw.configPath)) {
     return {
       configFound: false,
-      gatewayPort: null,
+      gatewayPort: envGatewayPort,
       authMode: null,
       token: readGatewayTokenEnv(),
       password: readGatewayPasswordEnv()
@@ -1145,13 +1146,13 @@ function readOpenClawInfo() {
   try {
     const parsed = JSON.parse(readFileSync3(openclaw.configPath, "utf8"));
     const rawPort = parsed.gateway?.port;
-    const gatewayPort = typeof rawPort === "number" && Number.isInteger(rawPort) ? rawPort : null;
+    const configuredGatewayPort = typeof rawPort === "number" && Number.isInteger(rawPort) ? rawPort : null;
     const authMode = parsed.gateway?.auth?.mode === "token" || parsed.gateway?.auth?.mode === "password" ? parsed.gateway.auth.mode : null;
     const token = readConfiguredSecret(parsed.gateway?.auth?.token) ?? readGatewayTokenEnv();
     const password = readConfiguredSecret(parsed.gateway?.auth?.password) ?? readGatewayPasswordEnv();
     return {
       configFound: true,
-      gatewayPort,
+      gatewayPort: envGatewayPort ?? configuredGatewayPort,
       authMode,
       token,
       password
@@ -1159,7 +1160,7 @@ function readOpenClawInfo() {
   } catch {
     return {
       configFound: true,
-      gatewayPort: null,
+      gatewayPort: envGatewayPort,
       authMode: null,
       token: readGatewayTokenEnv(),
       password: readGatewayPasswordEnv()
@@ -1233,6 +1234,337 @@ async function configureOpenClawLanAccess(params) {
     controlUiOrigin
   };
 }
+function stripAnsi(text) {
+  return text.replace(/\x1B\[[0-9;]*[a-zA-Z]/g, "");
+}
+function collectCliOutput(parts) {
+  return parts.filter((value) => typeof value === "string" && value.trim().length > 0).map((value) => stripAnsi(value.trim())).join("\n").trim();
+}
+function isUnsupportedJsonOptionOutput(text) {
+  return /unknown option ['"]?--json['"]?/i.test(text);
+}
+async function readOpenClawPermissions() {
+  const openclaw = resolveOpenClawPaths();
+  const config = await readJsonFile(openclaw.configPath);
+  const approvalsPath = resolveOpenClawExecApprovalsPath();
+  const approvals = await readJsonFile(approvalsPath);
+  const configEnv = readConfigEnvVars(config);
+  const tools = readRecord(config?.tools);
+  const currentAgent = resolveCurrentAgent(config);
+  const agentTools = readRecord(currentAgent.record?.tools);
+  const web = readRecord(tools?.web);
+  const webSearch = readRecord(web?.search);
+  const webFetch = readRecord(web?.fetch);
+  const exec = resolveMergedExecConfig(tools, agentTools);
+  const toolProfile = resolveToolProfile(tools, agentTools);
+  const toolDeny = uniqueSortedStrings([
+    ...readStringArray(tools?.deny),
+    ...readStringArray(agentTools?.deny)
+  ]);
+  const searchEnabled = readBoolean(webSearch?.enabled, true);
+  const searchProvider = readString(webSearch?.provider) ?? "auto";
+  const searchConfigured = resolveWebSearchConfigured(webSearch, searchProvider, configEnv);
+  const webReasons = [];
+  let webStatus;
+  let webSummary;
+  if (toolDeny.includes("web_search") && toolDeny.includes("web_fetch")) {
+    webStatus = "disabled";
+    webSummary = "Web search and fetch are blocked by tool policy.";
+    webReasons.push("Global tool policy denies both web_search and web_fetch.");
+  } else if (!searchEnabled && !readBoolean(webFetch?.enabled, true)) {
+    webStatus = "disabled";
+    webSummary = "Web search and fetch are turned off.";
+    webReasons.push("tools.web.search.enabled is false.");
+    webReasons.push("tools.web.fetch.enabled is false.");
+  } else if (searchEnabled && !searchConfigured) {
+    webStatus = "configuration_needed";
+    webSummary = "Web search is enabled, but no search provider key was found.";
+    webReasons.push(searchProvider === "auto" ? "No supported web search provider API key was found in config or current environment." : `Provider "${searchProvider}" is selected, but its API key was not found in config or current environment.`);
+  } else {
+    webStatus = "available";
+    webSummary = "Common web tools look available.";
+    if (toolDeny.includes("web_search")) {
+      webStatus = "restricted";
+      webSummary = "Web fetch is available, but web search is blocked by tool policy.";
+      webReasons.push("Global tool policy denies web_search.");
+    } else if (toolDeny.includes("web_fetch")) {
+      webStatus = "restricted";
+      webSummary = "Web search is available, but web fetch is blocked by tool policy.";
+      webReasons.push("Global tool policy denies web_fetch.");
+    } else {
+      if (!searchEnabled) {
+        webReasons.push("tools.web.search.enabled is false.");
+      }
+      if (!readBoolean(webFetch?.enabled, true)) {
+        webReasons.push("tools.web.fetch.enabled is false.");
+      }
+    }
+  }
+  const firecrawlConfigured = resolveFirecrawlConfigured(webFetch, configEnv);
+  const configuredHost = readExecHost(exec?.host);
+  const sandboxMode = readSandboxMode(config, currentAgent.id);
+  const implicitSandboxFallback = configuredHost === "sandbox" && sandboxMode === "off";
+  const effectiveHost = implicitSandboxFallback ? "gateway" : configuredHost;
+  const configSecurity = readExecSecurity(exec?.security, configuredHost === "sandbox" ? "deny" : "allowlist");
+  const configAsk = readExecAsk(exec?.ask, "on-miss");
+  const safeBins = readStringArray(exec?.safeBins);
+  const safeBinTrustedDirs = uniqueSortedStrings([
+    "/bin",
+    "/usr/bin",
+    ...readStringArray(exec?.safeBinTrustedDirs)
+  ]);
+  const trustedDirWarnings = safeBinTrustedDirs.filter((dir) => ["/opt/homebrew/bin", "/usr/local/bin", "/opt/local/bin", "/snap/bin"].includes(dir)).map((dir) => `safe-bin trust includes ${dir}; this is often needed, but commands there are treated as explicitly trusted.`);
+  const resolvedApprovals = resolveExecApprovalsSummary(approvals, {
+    security: configSecurity,
+    ask: configAsk
+  });
+  const usesHostApprovals = configuredHost === "gateway" || configuredHost === "node";
+  const effectiveSecurity = usesHostApprovals ? minExecSecurity(configSecurity, resolvedApprovals.security) : configSecurity;
+  const effectiveAsk = usesHostApprovals ? resolvedApprovals.ask === "off" ? "off" : maxExecAsk(configAsk, resolvedApprovals.ask) : "off";
+  const toolPolicyDenied = deniesExecTool(toolDeny);
+  const execToolAvailable = toolProfileAllowsExec(toolProfile) && !toolPolicyDenied;
+  const execReasons = [];
+  let execStatus;
+  let execSummary;
+  if (!execToolAvailable) {
+    execStatus = "disabled";
+    execSummary = "This agent cannot run commands right now.";
+    if (!toolProfileAllowsExec(toolProfile)) {
+      execReasons.push(`The current agent uses the ${toolProfile} tool profile, which does not expose command tools.`);
+    }
+    if (toolPolicyDenied) {
+      execReasons.push("A tool deny rule is blocking command execution for the current agent.");
+    }
+  } else if (implicitSandboxFallback) {
+    execStatus = "available";
+    execSummary = "Commands currently run directly on this OpenClaw machine.";
+    execReasons.push("The current agent still exposes command tools.");
+    execReasons.push("Sandbox mode is off, so commands are not running in an isolated sandbox.");
+    execReasons.push("OpenClaw is currently falling back to direct host execution on this machine.");
+  } else if (effectiveHost === "sandbox") {
+    execStatus = "available";
+    execSummary = "Commands run inside OpenClaw's sandbox.";
+    execReasons.push("The current agent still exposes command tools.");
+    execReasons.push(`Sandbox mode is ${sandboxMode}.`);
+  } else if (effectiveSecurity === "deny") {
+    execStatus = "disabled";
+    execSummary = "Command execution is disabled.";
+    execReasons.push(`Effective exec security resolves to ${effectiveSecurity}.`);
+  } else if (effectiveAsk !== "off") {
+    execStatus = "needs_approval";
+    execSummary = "Commands can run, but exec approvals currently require confirmation.";
+    execReasons.push(`Effective exec ask policy is ${effectiveAsk}.`);
+    if (effectiveSecurity === "allowlist" && resolvedApprovals.allowlistCount === 0 && safeBins.length === 0) {
+      execReasons.push("No allowlist entries or safe bins are configured yet, so most commands will still be denied.");
+    }
+  } else if (effectiveSecurity === "allowlist") {
+    execStatus = "restricted";
+    execSummary = "Commands are limited to allowlisted executables and safe bins.";
+    execReasons.push("Effective exec security is allowlist.");
+    if (resolvedApprovals.allowlistCount === 0 && safeBins.length === 0) {
+      execReasons.push("No allowlist entries or safe bins are configured yet.");
+    }
+  } else {
+    execStatus = "available";
+    execSummary = "Command execution is broadly available.";
+  }
+  if (usesHostApprovals && resolvedApprovals.security !== configSecurity) {
+    execReasons.push(`exec-approvals.json is stricter than tools.exec.security (${configSecurity} -> ${resolvedApprovals.security}).`);
+  }
+  if (usesHostApprovals && resolvedApprovals.ask !== configAsk) {
+    execReasons.push(`exec-approvals.json is stricter than tools.exec.ask (${configAsk} -> ${resolvedApprovals.ask}).`);
+  }
+  if (usesHostApprovals && safeBins.some(isInterpreterLikeSafeBin)) {
+    execStatus = execStatus === "disabled" ? execStatus : "restricted";
+    execReasons.push("Interpreter/runtime binaries appear in safeBins and may still be unsafe or blocked.");
+  }
+  if (usesHostApprovals) {
+    execReasons.push(...trustedDirWarnings);
+  }
+  if (!usesHostApprovals) {
+    execReasons.push(`The app controls tools.exec.security=${configSecurity} and tools.exec.ask=${configAsk}, but this current command path is not using OpenClaw's host approval flow.`);
+  }
+  const codeReasons = [];
+  let codeStatus = execStatus;
+  let codeSummary = execSummary;
+  if (!execToolAvailable) {
+    codeStatus = "disabled";
+    codeSummary = "Scripts are currently unavailable because this agent cannot run commands.";
+  } else if (implicitSandboxFallback) {
+    codeStatus = "available";
+    codeSummary = "Scripts follow the same direct command path as command execution on this machine.";
+    codeReasons.push("Code execution follows the same direct command path as command execution.");
+  } else if (effectiveHost === "sandbox") {
+    codeStatus = "available";
+    codeSummary = "Code runs inside OpenClaw's sandbox.";
+    codeReasons.push("Code execution follows the same sandboxed path as command execution.");
+  } else if (effectiveSecurity === "deny") {
+    codeStatus = "disabled";
+    codeSummary = "Code execution is disabled because command execution is disabled.";
+  } else if (effectiveAsk !== "off") {
+    codeStatus = "needs_approval";
+    codeSummary = "Running scripts or code inherits the current exec approval requirement.";
+    codeReasons.push("Interpreter and runtime commands inherit exec approval rules.");
+    codeReasons.push("Approval-backed interpreter runs are conservative and may be denied when OpenClaw cannot bind one concrete file.");
+  } else if (effectiveSecurity === "allowlist") {
+    codeStatus = "restricted";
+    codeSummary = "Running scripts is restricted by allowlist rules.";
+    codeReasons.push("Interpreter and runtime commands usually need explicit allowlist entries.");
+  } else {
+    codeStatus = "available";
+    codeSummary = "Code execution inherits the current command execution policy and looks available.";
+  }
+  if (safeBins.some(isInterpreterLikeSafeBin)) {
+    codeStatus = codeStatus === "disabled" ? codeStatus : "restricted";
+    codeReasons.push("Interpreter/runtime binaries should not rely on safeBins alone.");
+  }
+  return {
+    configPath: openclaw.configPath,
+    approvalsPath,
+    web: {
+      status: webStatus,
+      summary: webSummary,
+      reasons: uniqueSortedStrings(webReasons),
+      searchEnabled,
+      searchProvider,
+      searchConfigured,
+      fetchEnabled: readBoolean(webFetch?.enabled, true),
+      firecrawlConfigured
+    },
+    exec: {
+      currentAgentId: currentAgent.id,
+      currentAgentName: currentAgent.name,
+      toolProfile,
+      execToolAvailable,
+      hostApprovalsApply: usesHostApprovals,
+      implicitSandboxFallback,
+      status: execStatus,
+      summary: execSummary,
+      reasons: uniqueSortedStrings(execReasons),
+      configuredHost,
+      effectiveHost,
+      sandboxMode,
+      configSecurity,
+      configAsk,
+      approvalsExists: approvals != null,
+      approvalsSecurity: resolvedApprovals.security,
+      approvalsAsk: resolvedApprovals.ask,
+      effectiveSecurity,
+      effectiveAsk,
+      allowlistCount: resolvedApprovals.allowlistCount,
+      toolPolicyDenied,
+      safeBins,
+      safeBinTrustedDirs,
+      trustedDirWarnings
+    },
+    codeExecution: {
+      status: codeStatus,
+      summary: codeSummary,
+      reasons: uniqueSortedStrings(codeReasons),
+      inheritsFromExec: true
+    }
+  };
+}
+async function runOpenClawDoctor() {
+  const openclaw = resolveOpenClawPaths();
+  try {
+    const { stdout, stderr } = await runOpenClawCli(["doctor", "--json"], openclaw);
+    try {
+      const parsed = parseEmbeddedJsonValue(collectCliOutput([stdout, stderr]));
+      const checks = Array.isArray(parsed.checks) ? parsed.checks.filter((c) => typeof c === "object" && c != null).map((c) => ({
+        name: typeof c.name === "string" ? c.name : "unknown",
+        status: typeof c.status === "string" ? c.status : "unknown",
+        message: typeof c.message === "string" ? c.message : void 0
+      })) : [];
+      return {
+        ok: parsed.ok === true,
+        checks,
+        summary: typeof parsed.summary === "string" ? parsed.summary : ""
+      };
+    } catch {
+      return {
+        ok: true,
+        checks: [],
+        summary: "",
+        raw: collectCliOutput([stdout, stderr])
+      };
+    }
+  } catch (error) {
+    if (isExecFileError(error)) {
+      const output = collectCliOutput([error.stdout, error.stderr]);
+      if (output) {
+        if (isUnsupportedJsonOptionOutput(output)) {
+        } else {
+          try {
+            const parsed = parseEmbeddedJsonValue(output);
+            const checks = Array.isArray(parsed.checks) ? parsed.checks.filter((c) => typeof c === "object" && c != null).map((c) => ({
+              name: typeof c.name === "string" ? c.name : "unknown",
+              status: typeof c.status === "string" ? c.status : "unknown",
+              message: typeof c.message === "string" ? c.message : void 0
+            })) : [];
+            return {
+              ok: parsed.ok === true,
+              checks,
+              summary: typeof parsed.summary === "string" ? parsed.summary : ""
+            };
+          } catch {
+            return {
+              ok: false,
+              checks: [],
+              summary: "",
+              raw: output
+            };
+          }
+        }
+      }
+    }
+    try {
+      const { stdout, stderr } = await runOpenClawCli(["doctor"], openclaw);
+      return {
+        ok: true,
+        checks: [],
+        summary: "",
+        raw: collectCliOutput([stdout, stderr])
+      };
+    } catch (fallbackError) {
+      if (isExecFileError(fallbackError)) {
+        const output = collectCliOutput([fallbackError.stdout, fallbackError.stderr]);
+        if (output) {
+          return {
+            ok: false,
+            checks: [],
+            summary: "",
+            raw: output
+          };
+        }
+      }
+      throw fallbackError instanceof Error ? fallbackError : formatOpenClawCliError(["doctor"], fallbackError);
+    }
+  }
+}
+async function runOpenClawDoctorFix() {
+  const openclaw = resolveOpenClawPaths();
+  try {
+    const { stdout, stderr } = await runOpenClawCli(["doctor", "--fix"], openclaw);
+    return {
+      ok: true,
+      summary: "",
+      raw: collectCliOutput([stdout, stderr])
+    };
+  } catch (error) {
+    if (isExecFileError(error)) {
+      const output = collectCliOutput([error.stdout, error.stderr]);
+      if (output) {
+        return {
+          ok: false,
+          summary: "",
+          raw: output
+        };
+      }
+    }
+    throw formatOpenClawCliError(["doctor", "--fix"], error);
+  }
+}
 async function restartOpenClawGateway() {
   const openclaw = resolveOpenClawPaths();
   const restart = await runOpenClawDaemonCommand(["gateway", "restart", "--json"], openclaw);
@@ -1292,6 +1624,226 @@ async function issueOpenClawBootstrapToken(params) {
 function readConfiguredSecret(value) {
   return typeof value === "string" && value.trim() ? value.trim() : null;
 }
+function readRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+  return value;
+}
+function readString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function readBoolean(value, fallback) {
+  return typeof value === "boolean" ? value : fallback;
+}
+function readStringArray(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return uniqueSortedStrings(value.filter((entry) => typeof entry === "string").map((entry) => entry.trim()));
+}
+function uniqueSortedStrings(values) {
+  return [...new Set(values.filter((value) => value.trim().length > 0))].sort();
+}
+function resolveCurrentAgent(config) {
+  const agents = readRecord(config?.agents);
+  const list = Array.isArray(agents?.list) ? agents.list : [];
+  const entries = list.map((entry) => readRecord(entry)).filter((entry) => entry != null);
+  const target = entries.find((entry) => entry.default === true) ?? entries.find((entry) => readString(entry.id) === "main") ?? entries[0] ?? null;
+  const id = readString(target?.id) ?? "main";
+  const name = readString(target?.name) ?? id;
+  return { id, name, record: target };
+}
+function resolveToolProfile(globalTools, agentTools) {
+  const raw = readString(agentTools?.profile) ?? readString(globalTools?.profile);
+  return raw === "minimal" || raw === "coding" || raw === "messaging" || raw === "full" ? raw : "unset";
+}
+function toolProfileAllowsExec(profile) {
+  return profile === "coding" || profile === "full" || profile === "unset";
+}
+function deniesExecTool(denyList) {
+  const normalized = new Set(denyList.map((entry) => entry.trim().toLowerCase()).filter(Boolean));
+  return normalized.has("*") || normalized.has("exec") || normalized.has("bash") || normalized.has("group:runtime");
+}
+function resolveMergedExecConfig(globalTools, agentTools) {
+  const globalExec = readRecord(globalTools?.exec);
+  const agentExec = readRecord(agentTools?.exec);
+  if (!globalExec && !agentExec) {
+    return null;
+  }
+  return {
+    ...globalExec ?? {},
+    ...agentExec ?? {}
+  };
+}
+function readExecHost(value) {
+  return value === "gateway" || value === "node" || value === "sandbox" ? value : "sandbox";
+}
+function readSandboxMode(config, agentId = "main") {
+  const agents = readRecord(config?.agents);
+  const defaults = readRecord(agents?.defaults);
+  const defaultSandbox = readRecord(defaults?.sandbox);
+  const list = Array.isArray(agents?.list) ? agents.list : [];
+  const targetAgent = list.find((entry) => {
+    const record = readRecord(entry);
+    return readString(record?.id) === agentId;
+  });
+  const agentSandbox = readRecord(readRecord(targetAgent)?.sandbox);
+  const value = readString(agentSandbox?.mode) ?? readString(defaultSandbox?.mode);
+  return value === "all" || value === "non-main" || value === "off" ? value : "off";
+}
+function readExecSecurity(value, fallback) {
+  return value === "deny" || value === "allowlist" || value === "full" ? value : fallback;
+}
+function readExecAsk(value, fallback) {
+  return value === "off" || value === "on-miss" || value === "always" ? value : fallback;
+}
+function minExecSecurity(a, b) {
+  const order = { deny: 0, allowlist: 1, full: 2 };
+  return order[a] <= order[b] ? a : b;
+}
+function maxExecAsk(a, b) {
+  const order = { off: 0, "on-miss": 1, always: 2 };
+  return order[a] >= order[b] ? a : b;
+}
+function resolveWebSearchConfigured(webSearch, provider, configEnv) {
+  const braveKey = readConfiguredSecret(webSearch?.apiKey) ?? readConfigEnvValue(configEnv, "BRAVE_API_KEY") ?? readEnvValue("BRAVE_API_KEY", "BRAVE_API_KEY");
+  const gemini = readRecord(webSearch?.gemini);
+  const geminiKey = readConfiguredSecret(gemini?.apiKey) ?? readConfigEnvValue(configEnv, "GEMINI_API_KEY") ?? readEnvValue("GEMINI_API_KEY", "GEMINI_API_KEY");
+  const grok = readRecord(webSearch?.grok);
+  const grokKey = readConfiguredSecret(grok?.apiKey) ?? readConfigEnvValue(configEnv, "XAI_API_KEY") ?? readEnvValue("XAI_API_KEY", "XAI_API_KEY");
+  const kimi = readRecord(webSearch?.kimi);
+  const kimiKey = readConfiguredSecret(kimi?.apiKey) ?? readConfigEnvValue(configEnv, "KIMI_API_KEY", "MOONSHOT_API_KEY") ?? readConfigEnvValue(configEnv, "MOONSHOT_API_KEY", "KIMI_API_KEY") ?? readEnvValue("KIMI_API_KEY", "MOONSHOT_API_KEY") ?? readEnvValue("MOONSHOT_API_KEY", "KIMI_API_KEY");
+  const perplexity = readRecord(webSearch?.perplexity);
+  const perplexityKey = readConfiguredSecret(perplexity?.apiKey) ?? readConfigEnvValue(configEnv, "PERPLEXITY_API_KEY", "OPENROUTER_API_KEY") ?? readConfigEnvValue(configEnv, "OPENROUTER_API_KEY", "PERPLEXITY_API_KEY") ?? readEnvValue("PERPLEXITY_API_KEY", "OPENROUTER_API_KEY") ?? readEnvValue("OPENROUTER_API_KEY", "PERPLEXITY_API_KEY");
+  const configuredByProvider = {
+    brave: Boolean(braveKey),
+    gemini: Boolean(geminiKey),
+    grok: Boolean(grokKey),
+    kimi: Boolean(kimiKey),
+    perplexity: Boolean(perplexityKey)
+  };
+  if (provider !== "auto") {
+    return configuredByProvider[provider] === true;
+  }
+  return Object.values(configuredByProvider).some(Boolean);
+}
+function resolveFirecrawlConfigured(webFetch, configEnv) {
+  const firecrawl = readRecord(webFetch?.firecrawl);
+  return Boolean(readConfiguredSecret(firecrawl?.apiKey) ?? readConfigEnvValue(configEnv, "FIRECRAWL_API_KEY") ?? readEnvValue("FIRECRAWL_API_KEY", "FIRECRAWL_API_KEY"));
+}
+function readConfigEnvVars(config) {
+  const env = readRecord(config?.env);
+  if (!env) {
+    return {};
+  }
+  const vars = readRecord(env.vars);
+  const result = {};
+  if (vars) {
+    for (const [key, value] of Object.entries(vars)) {
+      const normalized = key.trim();
+      if (!normalized) {
+        continue;
+      }
+      const secret = readConfiguredSecret(value);
+      if (secret) {
+        result[normalized] = secret;
+      }
+    }
+  }
+  for (const [key, value] of Object.entries(env)) {
+    if (key === "vars" || key === "shellEnv") {
+      continue;
+    }
+    const normalized = key.trim();
+    if (!normalized) {
+      continue;
+    }
+    const secret = readConfiguredSecret(value);
+    if (secret) {
+      result[normalized] = secret;
+    }
+  }
+  return result;
+}
+function readConfigEnvValue(configEnv, primary, legacy) {
+  const current = configEnv[primary]?.trim();
+  if (current) {
+    return current;
+  }
+  if (!legacy) {
+    return null;
+  }
+  const fallback = configEnv[legacy]?.trim();
+  return fallback || null;
+}
+function resolveExecApprovalsSummary(approvals, overrides) {
+  const defaults = readRecord(approvals?.defaults);
+  const agents = readRecord(approvals?.agents);
+  const wildcard = readRecord(agents?.["*"]);
+  const main2 = readRecord(agents?.main) ?? readRecord(agents?.default);
+  const security = readExecSecurity(main2?.security ?? wildcard?.security ?? defaults?.security, readExecSecurity(defaults?.security, overrides.security));
+  const ask = readExecAsk(main2?.ask ?? wildcard?.ask ?? defaults?.ask, readExecAsk(defaults?.ask, overrides.ask));
+  const allowlistEntries = [
+    ...readAllowlistEntries(wildcard?.allowlist),
+    ...readAllowlistEntries(main2?.allowlist)
+  ];
+  return {
+    security,
+    ask,
+    allowlistCount: uniqueSortedStrings(allowlistEntries.map((entry) => entry.pattern)).length
+  };
+}
+function readAllowlistEntries(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  const entries = [];
+  for (const entry of value) {
+    const record = readRecord(entry);
+    const pattern = readString(record?.pattern);
+    if (pattern) {
+      entries.push({ pattern });
+    }
+  }
+  return entries;
+}
+function isInterpreterLikeSafeBin(value) {
+  const normalized = value.trim().toLowerCase().split(/[\\/]/).at(-1) ?? "";
+  if (!normalized) {
+    return false;
+  }
+  if ([
+    "ash",
+    "bash",
+    "bun",
+    "cmd",
+    "cmd.exe",
+    "dash",
+    "deno",
+    "fish",
+    "ksh",
+    "lua",
+    "node",
+    "nodejs",
+    "perl",
+    "php",
+    "powershell",
+    "powershell.exe",
+    "pypy",
+    "pwsh",
+    "pwsh.exe",
+    "python",
+    "python2",
+    "python3",
+    "ruby",
+    "sh",
+    "zsh"
+  ].includes(normalized)) {
+    return true;
+  }
+  return /^(python|ruby|perl|php|node)\d+(?:\.\d+)?$/.test(normalized);
+}
 async function readOpenClawConfigString(configPath, openclaw = resolveOpenClawPaths()) {
   try {
     const { stdout } = await runOpenClawCli(["config", "get", configPath], openclaw);
@@ -1358,7 +1910,7 @@ async function runOpenClawCli(args, openclaw = resolveOpenClawPaths()) {
       });
     });
   } catch (error) {
-    throw formatOpenClawCliError(args, error);
+    throw preserveExecFileErrorDetails(formatOpenClawCliError(args, error), error);
   }
 }
 function formatOpenClawCliError(args, error) {
@@ -1372,6 +1924,16 @@ function formatOpenClawCliError(args, error) {
   }
   return error instanceof Error ? error : new Error(`${messagePrefix} failed: ${String(error)}`);
 }
+function preserveExecFileErrorDetails(formatted, original) {
+  if (!isExecFileError(original)) {
+    return formatted;
+  }
+  return Object.assign(formatted, {
+    code: original.code,
+    stdout: original.stdout,
+    stderr: original.stderr
+  });
+}
 function isMissingConfigPathError(error) {
   return error instanceof Error && /Config path not found:/i.test(error.message);
 }
@@ -1499,6 +2061,13 @@ function readGatewayTokenEnv() {
 function readGatewayPasswordEnv() {
   return readEnvValue("OPENCLAW_GATEWAY_PASSWORD", "CLAWDBOT_GATEWAY_PASSWORD");
 }
+function readGatewayPortEnv() {
+  const raw = readEnvValue("OPENCLAW_GATEWAY_PORT", "CLAWDBOT_GATEWAY_PORT");
+  if (!raw)
+    return null;
+  const parsed = Number.parseInt(raw, 10);
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : null;
+}
 function readEnvValue(primary, legacy) {
   const current = process.env[primary]?.trim();
   if (current)
@@ -1516,6 +2085,9 @@ function resolveOpenClawPaths() {
     mediaDir: join3(stateDir, "media")
   };
 }
+function resolveOpenClawExecApprovalsPath() {
+  return join3(resolveOpenClawHomeDir(), ".openclaw", "exec-approvals.json");
+}
 function resolveActiveOpenClawStateDir() {
   const explicitStateDir = readEnvValue("OPENCLAW_STATE_DIR", "CLAWDBOT_STATE_DIR");
   if (explicitStateDir) {
@@ -1541,6 +2113,21 @@ function buildOpenClawStateDirCandidates() {
     return true;
   });
 }
+function resolveOpenClawHomeDir() {
+  const explicitHome = process.env.OPENCLAW_HOME?.trim();
+  if (explicitHome) {
+    return resolveUserPath(explicitHome);
+  }
+  const envHome = process.env.HOME?.trim();
+  if (envHome) {
+    return resolveUserPath(envHome);
+  }
+  const userProfile = process.env.USERPROFILE?.trim();
+  if (userProfile) {
+    return resolveUserPath(userProfile);
+  }
+  return resolve(homedir3());
+}
 function resolveUserPath(input) {
   const trimmed = input.trim();
   if (!trimmed)
@@ -1955,6 +2542,18 @@ var BridgeRuntime = class {
       await this.handleBootstrapRequest(control);
       return;
     }
+    if (control.event === "doctor.request") {
+      await this.handleDoctorRequest(control);
+      return;
+    }
+    if (control.event === "doctor-fix.request") {
+      await this.handleDoctorFixRequest(control);
+      return;
+    }
+    if (control.event === "permissions.request") {
+      await this.handlePermissionsRequest(control);
+      return;
+    }
     const { event, count } = control;
     if (event === "client_connected" || event === "client_count") {
       const previousClientCount = this.snapshot.clientCount;
@@ -2056,6 +2655,108 @@ var BridgeRuntime = class {
       });
     }
   }
+  async handleDoctorRequest(control) {
+    const requestId = control.requestId?.trim() ?? "";
+    const replyTargetClientId = control.sourceClientId?.trim() || control.targetClientId?.trim() || "";
+    if (!requestId) {
+      this.log("relay doctor request dropped reason=missing_request_id");
+      return;
+    }
+    this.log(`relay doctor request received requestId=${requestId}`);
+    try {
+      const result = await runOpenClawDoctor();
+      this.log(`relay doctor completed requestId=${requestId} ok=${result.ok} checks=${result.checks.length}`);
+      this.sendRelayControl({
+        event: "doctor.result",
+        requestId,
+        targetClientId: replyTargetClientId || void 0,
+        payload: {
+          ok: result.ok,
+          checks: result.checks,
+          summary: result.summary,
+          raw: result.raw
+        }
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.log(`relay doctor failed requestId=${requestId} error=${message}`);
+      this.sendRelayControl({
+        event: "doctor.error",
+        requestId,
+        targetClientId: replyTargetClientId || void 0,
+        payload: {
+          code: "doctor_failed",
+          message
+        }
+      });
+    }
+  }
+  async handleDoctorFixRequest(control) {
+    const requestId = control.requestId?.trim() ?? "";
+    const replyTargetClientId = control.sourceClientId?.trim() || control.targetClientId?.trim() || "";
+    if (!requestId) {
+      this.log("relay doctor-fix request dropped reason=missing_request_id");
+      return;
+    }
+    this.log(`relay doctor-fix request received requestId=${requestId}`);
+    try {
+      const result = await runOpenClawDoctorFix();
+      this.log(`relay doctor-fix completed requestId=${requestId} ok=${result.ok}`);
+      this.sendRelayControl({
+        event: "doctor-fix.result",
+        requestId,
+        targetClientId: replyTargetClientId || void 0,
+        payload: {
+          ok: result.ok,
+          summary: result.summary,
+          raw: result.raw
+        }
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.log(`relay doctor-fix failed requestId=${requestId} error=${message}`);
+      this.sendRelayControl({
+        event: "doctor-fix.error",
+        requestId,
+        targetClientId: replyTargetClientId || void 0,
+        payload: {
+          code: "doctor_fix_failed",
+          message
+        }
+      });
+    }
+  }
+  async handlePermissionsRequest(control) {
+    const requestId = control.requestId?.trim() ?? "";
+    const replyTargetClientId = control.sourceClientId?.trim() || control.targetClientId?.trim() || "";
+    if (!requestId) {
+      this.log("relay permissions request dropped reason=missing_request_id");
+      return;
+    }
+    this.log(`relay permissions request received requestId=${requestId}`);
+    try {
+      const result = await readOpenClawPermissions();
+      this.log(`relay permissions completed requestId=${requestId} execStatus=${result.exec.status} webStatus=${result.web.status}`);
+      this.sendRelayControl({
+        event: "permissions.result",
+        requestId,
+        targetClientId: replyTargetClientId || void 0,
+        payload: result
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.log(`relay permissions failed requestId=${requestId} error=${message}`);
+      this.sendRelayControl({
+        event: "permissions.error",
+        requestId,
+        targetClientId: replyTargetClientId || void 0,
+        payload: {
+          code: "permissions_failed",
+          message
+        }
+      });
+    }
+  }
   forwardOrQueueGatewayMessage(message) {
     const isConnectHandshake = message.kind === "text" && isConnectHandshakeRequest(message.text);
     if (this.gatewayCloseBoundaryPending) {
@@ -2612,7 +3313,7 @@ function redactAuthorizationHeader(value) {
   return /^Bearer\s+/i.test(trimmed) ? "Bearer <redacted>" : "<redacted>";
 }
 function sanitizeRuntimeLogLine(line) {
-  return line;
+  return line.replace(/\b(instanceId|clientId|sourceClientId|targetClientId|deviceId|requestId|reqId|traceId)=([^\s]+)/g, "$1=<redacted>").replace(/\b(relay|client)=([^\s]+)/g, "$1=<redacted>").replace(/\b(grs_[A-Za-z0-9_-]+|gct_[A-Za-z0-9_-]+)\b/g, "<redacted>");
 }
 function redactGatewayWsUrl(rawUrl) {
   const parsed = new URL(rawUrl);