mcp-for-i 0.1.13 → 0.3.0

package/dist/controlplane/server.js

@@ -10,46 +10,143 @@ import { ConnectionService } from "./connectionService.js";
 import { RuntimeService } from "./runtimeService.js";
 import { ClientIntegrationService } from "./clientIntegrationService.js";
 import { renderControlPlaneHtml } from "./ui.js";
+import { ControlPlaneError } from "./errors.js";
+import { HEALTH_SERVICE_ID } from "./serverShared.js";
+import { CONTROL_TOKEN_HEADER, ensureControlToken, isAllowedHostHeader, isAllowedOrigin, tokensMatch } from "./auth.js";
+/** Largest accepted request body. Bigger bodies get 413. */
+export const MAX_BODY_BYTES = 1024 * 1024;
 export async function startControlPlaneServer(opts) {
     const host = opts?.host || process.env.MCP_FOR_I_CONTROL_HOST || "127.0.0.1";
-    const port = normalizePort(opts?.port || Number(process.env.MCP_FOR_I_CONTROL_PORT || 3980));
+    const port = typeof opts?.port === "number"
+        ? normalizePort(opts.port, true)
+        : normalizePort(Number(process.env.MCP_FOR_I_CONTROL_PORT || 3980));
     const rootDir = opts?.rootDir || process.env.MCP_FOR_I_ROOT_DIR || getDefaultRootDir();
+    const token = opts?.token || ensureControlToken();
     const store = new ConfigStore();
     const connections = new ConnectionService(store);
     const runtime = new RuntimeService(rootDir);
     const clients = new ClientIntegrationService(rootDir);
+    const guard = { token, port, extraHosts: extraAllowedHosts(host) };
+    let markShutdown = () => undefined;
+    const shutdownRequested = new Promise(resolve => { markShutdown = resolve; });
+    const requestShutdown = () => {
+        markShutdown(true);
+        server.close();
+        server.closeAllConnections();
+    };
     const server = http.createServer(async (req, res) => {
         try {
-            await routeRequest(req, res, { store, connections, runtime, clients });
+            if (!checkRequest(req, res, guard))
+                return;
+            await routeRequest(req, res, { store, connections, runtime, clients, token, requestShutdown });
         }
         catch (err) {
-            sendJson(res, 500, { error: err?.message || String(err) });
+            if (res.headersSent) {
+                res.destroy();
+                return;
+            }
+            const status = err instanceof ControlPlaneError ? err.status : 500;
+            if (status === 413)
+                res.setHeader("Connection", "close");
+            sendJson(res, status, { error: err?.message || String(err) });
         }
     });
     await new Promise((resolve, reject) => {
         server.once("error", reject);
         server.listen(port, host, () => resolve());
     });
+    guard.port = server.address().port;
+    const closed = new Promise(resolve => server.once("close", () => {
+        markShutdown(false);
+        resolve();
+    }));
     return {
         host,
-        port,
+        port: guard.port,
+        token,
+        closed,
+        shutdownRequested,
         close: () => new Promise((resolve, reject) => {
             server.close(err => (err ? reject(err) : resolve()));
+            server.closeIdleConnections();
         })
     };
 }
+/**
+ * Rejects requests that did not come from the local Web UI or CLI: a wrong Host
+ * header (DNS rebinding), a foreign Origin, a missing token on /api routes,
+ * non-JSON bodies, and bodies over the size limit.
+ */
+function checkRequest(req, res, guard) {
+    if (!isAllowedHostHeader(req.headers.host, guard.port, guard.extraHosts)) {
+        rejectRequest(req, res, 421, "Host not allowed");
+        return false;
+    }
+    const origin = typeof req.headers.origin === "string" ? req.headers.origin : undefined;
+    if (!isAllowedOrigin(origin, guard.port, guard.extraHosts) || req.headers["sec-fetch-site"] === "cross-site") {
+        rejectRequest(req, res, 403, "Cross-origin requests are not allowed");
+        return false;
+    }
+    const pathname = (req.url || "/").split("?")[0];
+    if (!pathname.startsWith("/api/"))
+        return true;
+    // /api/health answers without a token so launchers can probe liveness,
+    // but it only returns details when the token is present.
+    const isHealth = pathname === "/api/health" && (req.method === "GET" || req.method === "HEAD");
+    if (!isHealth && !tokensMatch(guard.token, req.headers[CONTROL_TOKEN_HEADER.toLowerCase()])) {
+        rejectRequest(req, res, 401, `Missing or invalid ${CONTROL_TOKEN_HEADER} header`);
+        return false;
+    }
+    const method = req.method || "GET";
+    if (method !== "GET" && method !== "HEAD" && method !== "DELETE") {
+        const contentType = String(req.headers["content-type"] || "").split(";")[0].trim().toLowerCase();
+        if (contentType !== "application/json") {
+            rejectRequest(req, res, 415, "Content-Type must be application/json");
+            return false;
+        }
+    }
+    const declared = Number(req.headers["content-length"]);
+    if (Number.isFinite(declared) && declared > MAX_BODY_BYTES) {
+        rejectRequest(req, res, 413, `Request body exceeds ${MAX_BODY_BYTES} bytes`);
+        return false;
+    }
+    return true;
+}
+function rejectRequest(req, res, status, error) {
+    // Do not read a rejected body; close the connection once the reply is sent.
+    res.setHeader("Connection", "close");
+    sendJson(res, status, { error });
+    req.resume();
+}
+function extraAllowedHosts(bindHost) {
+    const lower = bindHost.trim().toLowerCase();
+    if (!lower || lower === "0.0.0.0" || lower === "::" || lower === "[::]")
+        return [];
+    return [lower];
+}
 async function routeRequest(req, res, services) {
     const method = req.method || "GET";
     const url = new URL(req.url || "/", "http://127.0.0.1");
     const pathname = url.pathname;
     if (method === "GET" && pathname === "/") {
-        res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
-        res.end(renderControlPlaneHtml());
+        res.writeHead(200, {
+            "Content-Type": "text/html; charset=utf-8",
+            "Cache-Control": "no-store",
+            "X-Frame-Options": "DENY",
+            "Content-Security-Policy": "frame-ancestors 'none'",
+            "Referrer-Policy": "no-referrer",
+            "X-Content-Type-Options": "nosniff"
+        });
+        res.end(renderControlPlaneHtml(services.token));
         return;
     }
     if (method === "GET" && pathname === "/api/health") {
+        if (!tokensMatch(services.token, req.headers[CONTROL_TOKEN_HEADER.toLowerCase()])) {
+            sendJson(res, 200, { ok: true, service: HEALTH_SERVICE_ID });
+            return;
+        }
         const credentialStore = await getCredentialStoreStatus();
-        sendJson(res, 200, { ok: true, keychainAvailable: credentialStore.keychainAvailable, credentialStore });
+        sendJson(res, 200, { ok: true, service: HEALTH_SERVICE_ID, keychainAvailable: credentialStore.keychainAvailable, credentialStore });
         return;
     }
     if (method === "GET" && pathname === "/api/settings") {
@@ -84,10 +181,20 @@ async function routeRequest(req, res, services) {
         sendJson(res, 200, { settings });
         return;
     }
+    if (method === "POST" && pathname === "/api/shutdown") {
+        // Answer first, then stop listening and drop the remaining connections.
+        res.once("finish", () => setImmediate(services.requestShutdown));
+        sendJson(res, 200, { stopping: true });
+        return;
+    }
     if (method === "GET" && pathname === "/api/sessions") {
         sendJson(res, 200, { snapshot: await readSessionSnapshot() });
         return;
     }
+    if (method === "GET" && pathname === "/api/tn5250/live") {
+        sendJson(res, 200, { views: await readLiveViews() });
+        return;
+    }
     if (method === "GET" && pathname === "/api/runtime/status") {
         sendJson(res, 200, { jobs: services.runtime.getStatus() });
         return;
@@ -161,6 +268,18 @@ async function routeRequest(req, res, services) {
         sendJson(res, 201, { connection: created });
         return;
     }
+    if (method === "POST" && pathname === "/api/connections/test") {
+        const body = await readJson(req);
+        const result = await services.connections.testDetails(body);
+        sendJson(res, 200, { result });
+        return;
+    }
+    const matchTest = pathname.match(/^\/api\/connections\/([^/]+)\/test$/);
+    if (matchTest && method === "POST") {
+        const result = await services.connections.testSaved(decodeURIComponent(matchTest[1]));
+        sendJson(res, 200, { result });
+        return;
+    }
     const matchConn = pathname.match(/^\/api\/connections\/([^/]+)$/);
     if (matchConn) {
         const name = decodeURIComponent(matchConn[1]);
@@ -227,20 +346,33 @@ function sendNoContent(res) {
 }
 async function readJson(req) {
     const chunks = [];
+    let total = 0;
     for await (const chunk of req) {
-        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+        const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        total += buf.length;
+        if (total > MAX_BODY_BYTES) {
+            throw new ControlPlaneError(413, `Request body exceeds ${MAX_BODY_BYTES} bytes`);
+        }
+        chunks.push(buf);
     }
     const raw = Buffer.concat(chunks).toString("utf8");
     if (!raw.trim())
         return {};
+    let parsed;
     try {
-        return JSON.parse(raw);
+        parsed = JSON.parse(raw);
     }
     catch {
-        throw new Error("Invalid JSON body");
+        throw new ControlPlaneError(400, "Invalid JSON body");
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new ControlPlaneError(400, "JSON body must be an object");
     }
+    return parsed;
 }
-function normalizePort(port) {
+function normalizePort(port, allowEphemeral = false) {
+    if (allowEphemeral && port === 0)
+        return 0;
     if (!Number.isFinite(port) || port <= 0 || port > 65535)
         return 3980;
     return Math.floor(port);
@@ -264,6 +396,41 @@ function parseNumberSetting(input, min, max, key) {
     }
     return normalized;
 }
+/**
+ * Live 5250 views: each MCP process that serves one writes a file with its
+ * address and sessions. Entries whose server no longer answers are dropped.
+ */
+async function readLiveViews() {
+    const dir = path.join(getConfigDir(), "tn5250-live");
+    let names = [];
+    try {
+        names = (await fsp.readdir(dir)).filter(name => name.endsWith(".json"));
+    }
+    catch {
+        return [];
+    }
+    const views = [];
+    for (const name of names) {
+        const file = path.join(dir, name);
+        try {
+            const entry = JSON.parse(await fsp.readFile(file, "utf8"));
+            if (!entry || typeof entry.url !== "string" || typeof entry.port !== "number")
+                throw new Error("bad entry");
+            const controller = new AbortController();
+            const timer = setTimeout(() => controller.abort(), 1000);
+            const alive = await fetch(`http://127.0.0.1:${entry.port}/api/sessions?t=${new URL(entry.url).searchParams.get("t")}`, { signal: controller.signal })
+                .then(r => r.ok).catch(() => false);
+            clearTimeout(timer);
+            if (!alive)
+                throw new Error("gone");
+            views.push({ pid: entry.pid, port: entry.port, url: entry.url, sessions: entry.sessions || [], updatedAt: entry.updatedAt });
+        }
+        catch {
+            await fsp.rm(file, { force: true }).catch(() => undefined);
+        }
+    }
+    return views;
+}
 async function readSessionSnapshot() {
     const snapshotPath = path.join(getConfigDir(), "session-state.json");
     try {

package/dist/controlplane/serverShared.js

@@ -1,16 +1,35 @@
-export function getControlPlaneUrl() {
-    const host = process.env.MCP_FOR_I_CONTROL_HOST || "127.0.0.1";
+import { CONTROL_TOKEN_HEADER, readControlToken } from "./auth.js";
+/** Marker returned by /api/health so callers know they reached this service. */
+export const HEALTH_SERVICE_ID = "mcp-for-i-control";
+export function getControlPlanePort() {
     const portRaw = Number(process.env.MCP_FOR_I_CONTROL_PORT || 3980);
-    const port = Number.isFinite(portRaw) && portRaw > 0 && portRaw <= 65535 ? Math.floor(portRaw) : 3980;
-    return `http://${host}:${port}`;
+    return Number.isFinite(portRaw) && portRaw > 0 && portRaw <= 65535 ? Math.floor(portRaw) : 3980;
+}
+export function getControlPlaneUrl() {
+    const configured = (process.env.MCP_FOR_I_CONTROL_HOST || "").trim();
+    // A wildcard bind address is not a valid Host for the server's checks.
+    const host = !configured || ["0.0.0.0", "::", "[::]"].includes(configured) ? "127.0.0.1" : configured;
+    const urlHost = host.includes(":") && !host.startsWith("[") ? `[${host}]` : host;
+    return `http://${urlHost}:${getControlPlanePort()}`;
+}
+/** Headers the CLI sends to the control plane (includes the per-install token). */
+export function getControlPlaneAuthHeaders() {
+    const token = readControlToken();
+    return token ? { [CONTROL_TOKEN_HEADER]: token } : {};
 }
 export async function isControlPlaneRunning(baseUrl = getControlPlaneUrl()) {
     try {
         const controller = new AbortController();
         const timeout = setTimeout(() => controller.abort(), 1500);
-        const res = await fetch(`${baseUrl}/api/health`, { signal: controller.signal });
+        const res = await fetch(`${baseUrl}/api/health`, {
+            signal: controller.signal,
+            headers: getControlPlaneAuthHeaders()
+        });
         clearTimeout(timeout);
-        return res.ok;
+        if (!res.ok)
+            return false;
+        const body = await res.json().catch(() => null);
+        return Boolean(body?.ok);
     }
     catch {
         return false;

package/dist/controlplane/serviceManager.js

@@ -4,7 +4,7 @@ import path from "path";
 import { spawn } from "child_process";
 import { getConfigDir } from "../config/store.js";
 import { getPlatformDescriptor } from "./platform.js";
-import { isControlPlaneRunning } from "./serverShared.js";
+import { getControlPlaneAuthHeaders, getControlPlanePort, getControlPlaneUrl, isControlPlaneRunning } from "./serverShared.js";
 const SERVICE_ID = "mcp-for-i-controlplane";
 const MAC_LABEL = "com.mcpfori.controlplane";
 const RC_BEGIN = "# >>> mcp-for-i control >>>";
@@ -87,6 +87,40 @@ export async function disableBackgroundService(scriptPath, nodePath = process.ex
     }
     return getServiceStatus(scriptPath, nodePath);
 }
+export async function stopControlPlane(scriptPath, nodePath = process.execPath, timeoutMs = 10000) {
+    const status = await getServiceStatus(scriptPath, nodePath).catch(() => undefined);
+    const base = { serviceEnabled: Boolean(status?.enabled), managedBy: status?.managedBy };
+    if (!(await isControlPlaneRunning()))
+        return { ...base, wasRunning: false, stopped: true };
+    if (process.platform === "darwin" && (await pathExists(getMacLaunchAgentPath()))) {
+        await runQuiet("launchctl", ["unload", getMacLaunchAgentPath()]);
+    }
+    else if (process.platform === "linux" && (await canUseSystemdUser()) && (await isSystemdActive())) {
+        await runQuiet("systemctl", ["--user", "stop", SERVICE_ID]);
+    }
+    let detail;
+    if (await isControlPlaneRunning()) {
+        try {
+            const res = await fetch(`${getControlPlaneUrl()}/api/shutdown`, {
+                method: "POST",
+                headers: { ...getControlPlaneAuthHeaders(), "Content-Type": "application/json" },
+                body: "{}"
+            });
+            if (!res.ok)
+                detail = `shutdown request failed with HTTP ${res.status}`;
+        }
+        catch {
+            // the server may drop the connection while it stops
+        }
+    }
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (!(await isControlPlaneRunning()))
+            return { ...base, wasRunning: true, stopped: true };
+        await wait(250);
+    }
+    return { ...base, wasRunning: true, stopped: false, detail };
+}
 export async function ensureControlPlaneRunning(scriptPath, nodePath = process.execPath, timeoutMs = 15000) {
     if (await isControlPlaneRunning()) {
         return { started: false };
@@ -121,6 +155,7 @@ async function enableWindowsStartup(scriptPath, nodePath) {
     const startupScript = [
         "@echo off",
         "setlocal",
+        `set "MCP_FOR_I_CONTROL_PORT=${getControlPlanePort()}"`,
         `start \"\" /MIN ${command}`,
         "exit /b 0"
     ].join("\r\n");
@@ -133,28 +168,28 @@ async function enableMacLaunchAgent(scriptPath, nodePath) {
     const errPath = path.join(configDir, "controlplane.err.log");
     await fs.mkdir(path.dirname(agentPath), { recursive: true });
     await fs.mkdir(configDir, { recursive: true });
-    const plist = `<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-  <key>Label</key>
-  <string>${MAC_LABEL}</string>
-  <key>ProgramArguments</key>
-  <array>
-    <string>${escapeXml(nodePath)}</string>
-    <string>${escapeXml(scriptPath)}</string>
-    <string>serve</string>
-  </array>
-  <key>RunAtLoad</key>
-  <true/>
-  <key>KeepAlive</key>
-  <true/>
-  <key>StandardOutPath</key>
-  <string>${escapeXml(outPath)}</string>
-  <key>StandardErrorPath</key>
-  <string>${escapeXml(errPath)}</string>
-</dict>
-</plist>
+    const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${MAC_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${escapeXml(nodePath)}</string>
+    <string>${escapeXml(scriptPath)}</string>
+    <string>serve</string>
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${escapeXml(outPath)}</string>
+  <key>StandardErrorPath</key>
+  <string>${escapeXml(errPath)}</string>
+</dict>
+</plist>
 `;
     await fs.writeFile(agentPath, plist, "utf8");
     await runQuiet("launchctl", ["unload", agentPath]);
@@ -170,20 +205,21 @@ async function enableLinuxSystemdService(scriptPath, nodePath) {
     const configDir = getConfigDir();
     await fs.mkdir(path.dirname(unitPath), { recursive: true });
     await fs.mkdir(configDir, { recursive: true });
-    const unit = `[Unit]
-Description=MCP-for-i control plane
-After=network.target
-
-[Service]
-Type=simple
-ExecStart=${systemdQuote(nodePath)} ${systemdQuote(scriptPath)} serve
-Restart=on-failure
-RestartSec=3
-WorkingDirectory=${systemdQuote(path.dirname(scriptPath))}
-Environment=MCP_FOR_I_CONTROL_HOST=127.0.0.1
-
-[Install]
-WantedBy=default.target
+    const unit = `[Unit]
+Description=MCP-for-i control plane
+After=network.target
+
+[Service]
+Type=simple
+ExecStart=${systemdQuote(nodePath)} ${systemdQuote(scriptPath)} serve
+Restart=on-failure
+RestartSec=3
+WorkingDirectory=${systemdQuote(path.dirname(scriptPath))}
+Environment=MCP_FOR_I_CONTROL_HOST=127.0.0.1
+Environment=MCP_FOR_I_CONTROL_PORT=${getControlPlanePort()}
+
+[Install]
+WantedBy=default.target
 `;
     await fs.writeFile(unitPath, unit, "utf8");
     await runOrThrow("systemctl", ["--user", "daemon-reload"]);
@@ -214,73 +250,84 @@ async function disableBashRcHook() {
     }
 }
 async function writeBashLauncher(launcherPath, scriptPath, nodePath) {
-    const configDir = getConfigDir();
-    const logFile = path.join(configDir, "controlplane.log");
-    const pythonHealthUrl = JSON.stringify("http://127.0.0.1:3980/api/health");
-    const script = `#!/usr/bin/env bash
-set -euo pipefail
-
-URL="http://127.0.0.1:3980/api/health"
-LOG_FILE=${shellQuote(logFile)}
-LOCK_DIR="\${XDG_RUNTIME_DIR:-/tmp}/${SERVICE_ID}.lock"
-
-mkdir -p "$(dirname "$LOG_FILE")"
-
-health_check() {
-  if command -v curl >/dev/null 2>&1; then
-    curl -fsS --max-time 1 "$URL" >/dev/null 2>&1
-    return $?
-  fi
-
-  if command -v wget >/dev/null 2>&1; then
-    wget -q -T 1 -O - "$URL" >/dev/null 2>&1
-    return $?
-  fi
-
-  if command -v python3 >/dev/null 2>&1; then
-    python3 - <<'PY' >/dev/null 2>&1
-import sys, urllib.request
-try:
-    with urllib.request.urlopen(${pythonHealthUrl}, timeout=1) as response:
-        sys.exit(0 if response.status == 200 else 1)
-except Exception:
-    sys.exit(1)
-PY
-    return $?
-  fi
-
-  return 1
-}
-
-if health_check; then
-  exit 0
-fi
-
-if mkdir "$LOCK_DIR" 2>/dev/null; then
-  trap 'rmdir "$LOCK_DIR" >/dev/null 2>&1 || true' EXIT
-else
-  exit 0
-fi
-
-if health_check; then
-  exit 0
-fi
-
-nohup ${shellQuote(nodePath)} ${shellQuote(scriptPath)} serve >>"$LOG_FILE" 2>&1 </dev/null &
-`;
+    const logFile = path.join(getConfigDir(), "controlplane.log");
+    const script = buildBashLauncherScript({ scriptPath, nodePath, logFile, port: getControlPlanePort() });
     await fs.writeFile(launcherPath, script, { encoding: "utf8", mode: 0o755 });
 }
+/**
+ * Builds the Bash launcher. The port defaults to the one configured when the
+ * service was enabled and can be overridden with MCP_FOR_I_CONTROL_PORT.
+ */
+export function buildBashLauncherScript(opts) {
+    const { scriptPath, nodePath, logFile } = opts;
+    const port = Number.isInteger(opts.port) && opts.port > 0 && opts.port <= 65535 ? opts.port : 3980;
+    return `#!/usr/bin/env bash
+set -euo pipefail
+
+PORT="\${MCP_FOR_I_CONTROL_PORT:-${port}}"
+case "$PORT" in
+  ""|*[!0-9]*) PORT=${port} ;;
+esac
+URL="http://127.0.0.1:\${PORT}/api/health"
+LOG_FILE=${shellQuote(logFile)}
+LOCK_DIR="\${XDG_RUNTIME_DIR:-/tmp}/${SERVICE_ID}.lock"
+
+mkdir -p "$(dirname "$LOG_FILE")"
+
+health_check() {
+  if command -v curl >/dev/null 2>&1; then
+    curl -fsS --max-time 1 "$URL" >/dev/null 2>&1
+    return $?
+  fi
+
+  if command -v wget >/dev/null 2>&1; then
+    wget -q -T 1 -O - "$URL" >/dev/null 2>&1
+    return $?
+  fi
+
+  if command -v python3 >/dev/null 2>&1; then
+    HEALTH_URL="$URL" python3 - <<'PY' >/dev/null 2>&1
+import os, sys, urllib.request
+try:
+    with urllib.request.urlopen(os.environ["HEALTH_URL"], timeout=1) as response:
+        sys.exit(0 if response.status == 200 else 1)
+except Exception:
+    sys.exit(1)
+PY
+    return $?
+  fi
+
+  return 1
+}
+
+if health_check; then
+  exit 0
+fi
+
+if mkdir "$LOCK_DIR" 2>/dev/null; then
+  trap 'rmdir "$LOCK_DIR" >/dev/null 2>&1 || true' EXIT
+else
+  exit 0
+fi
+
+if health_check; then
+  exit 0
+fi
+
+MCP_FOR_I_CONTROL_PORT="$PORT" nohup ${shellQuote(nodePath)} ${shellQuote(scriptPath)} serve >>"$LOG_FILE" 2>&1 </dev/null &
+`;
+}
 function createBashRcBlock(launcherPath, wslOnly) {
     const guard = wslOnly ? 'if [ -n "${WSL_DISTRO_NAME:-}" ]' : "if true";
-    return `${RC_BEGIN}
-case $- in
-  *i*) ;;
-  *) return ;;
-esac
-
-${guard} && [ -x ${shellQuote(launcherPath)} ]; then
-  ${shellQuote(launcherPath)} >/dev/null 2>&1 &
-fi
+    return `${RC_BEGIN}
+case $- in
+  *i*) ;;
+  *) return ;;
+esac
+
+${guard} && [ -x ${shellQuote(launcherPath)} ]; then
+  ${shellQuote(launcherPath)} >/dev/null 2>&1 &
+fi
 ${RC_END}`;
 }
 async function hasManagedRcBlock(rcPath) {