jishushell 0.6.5 → 0.6.18

package/dist/services/system-reconciler.d.ts

@@ -1,72 +0,0 @@
-/**
- * src/services/system-reconciler.ts
- *
- * Compares the system state rendered by the currently installed code against
- * host files/services, then applies the shared setup-manager installers when
- * privileged, domain-specific changes are needed.
- */
-import { type RuntimeRestartAdvisory } from "./runtime-repair.js";
-export type ReconcileFix = "none" | "system-reload" | "docker-pull" | "manual";
-export interface ReconcileItemResult {
-    component: string;
-    status: "ok" | "updated" | "skipped" | "error";
-    message: string;
-    /** Stable resource id from the expected-state renderer */
-    id?: string;
-    /** Host path that was compared */
-    path?: string;
-    /** True if this item requires sudo/root to fix */
-    requiresSudo?: boolean;
-    /** True if service reload/restart is needed before the rendered state is active */
-    reloadRequired?: boolean;
-    /** True if an operator action is required */
-    manualRequired?: boolean;
-    /** Machine-readable fix category */
-    fix?: ReconcileFix;
-    /** Exact command the user should run to fix this item */
-    command?: string;
-    /** Hashes are over normalized text, so irrelevant final newlines do not churn */
-    expectedHash?: string;
-    actualHash?: string;
-    /** Additional technical details for debugging */
-    details?: string;
-    /** Severity for UI display prioritization */
-    severity?: "info" | "warning" | "error";
-}
-export interface ReconcileResult {
-    timestamp: string;
-    items: ReconcileItemResult[];
-    runtime: ReconcileRuntimeState;
-    /** True if any items require sudo and were not fixed */
-    hasPendingSudoActions: boolean;
-    /** True if current rendered system state is not active until reload/restart */
-    reloadRequired: boolean;
-    /** True if one or more runtime instances need start/restart to apply repaired job specs */
-    runtimeRestartRequired: boolean;
-    /** True if an operator action is required */
-    manualRequired: boolean;
-    /** True when the local process has enough privilege to apply reload-required fixes */
-    canAutoReload: boolean;
-    /** Standard command to converge system state */
-    command: string;
-}
-export interface ReconcileRuntimeState {
-    restartRequired: boolean;
-    instances: RuntimeRestartAdvisory[];
-}
-export interface SystemReloadStartResult {
-    accepted: true;
-    command: string;
-    message: string;
-    state: ReconcileResult | null;
-    unit?: string;
-}
-export interface SystemReloadStartOptions {
-    restartInstances?: boolean;
-}
-export declare function inspectSystemDrift(): Promise<ReconcileResult>;
-export declare function reconcileSystem(): Promise<ReconcileResult>;
-export declare function persistRuntimeRestartAdvisories(instances: RuntimeRestartAdvisory[]): Promise<ReconcileResult>;
-export declare function clearRuntimeRestartAdvisory(instanceId: string): Promise<ReconcileResult | null>;
-export declare function acknowledgeRuntimeRestartAdvisory(instanceId: string): Promise<ReconcileResult | null>;
-export declare function startSystemReloadWithSudo(sudoPassword: string, options?: SystemReloadStartOptions): Promise<SystemReloadStartResult>;

package/dist/services/system-reconciler.js

@@ -1,600 +0,0 @@
-/**
- * src/services/system-reconciler.ts
- *
- * Compares the system state rendered by the currently installed code against
- * host files/services, then applies the shared setup-manager installers when
- * privileged, domain-specific changes are needed.
- */
-import { execFileSync } from "child_process";
-import { createHash } from "crypto";
-import { existsSync, lstatSync, readFileSync, writeFileSync } from "fs";
-import { userInfo } from "os";
-import { dirname, join } from "path";
-import { JISHUSHELL_HOME, getCoreConfig, getCorePort, getRuntimeCatalogEntry } from "../config.js";
-import { ensureDirHost } from "../utils/fs.js";
-import { createInvalidSudoPasswordError, isSudoAuthenticationError, isSudoNoNewPrivilegesError, runSudoAskpassCommand, } from "../utils/sudo-askpass.js";
-import * as setupManager from "./setup-manager.js";
-import { listRegisteredAdapters } from "./runtime/index.js";
-import { chownToServiceUser } from "./instance-manager.js";
-import { LEGACY_JOB_SPEC_RESTART_ADVISORY_ID, markRuntimeRestartAdvisoryApplied, } from "./runtime-repair.js";
-const RECONCILE_STATE_FILE = join(JISHUSHELL_HOME, "reconcile-state.json");
-// ── Helpers ────────────────────────────────────────────────────────────────
-function hasSudoAccess() {
-    if (typeof process.getuid === "function" && process.getuid() === 0)
-        return true;
-    try {
-        execFileSync("sudo", ["-n", "true"], { stdio: "ignore", timeout: 3000 });
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function shellQuote(value) {
-    return `'${value.replace(/'/g, "'\\''")}'`;
-}
-function getSystemReloadWrapper() {
-    return join(JISHUSHELL_HOME, "bin", "jishushell");
-}
-function sudoEnvPrefix() {
-    return `env JISHUSHELL_HOME=${shellQuote(JISHUSHELL_HOME)} HOME=${shellQuote(dirname(JISHUSHELL_HOME))}`;
-}
-function buildSudoDisplayCommand(command, args) {
-    return `sudo ${sudoEnvPrefix()} ${[command, ...args].map(shellQuote).join(" ")}`;
-}
-function resolveCurrentCliTarget(candidate, extraArgs = []) {
-    const cliPath = candidate?.trim();
-    if (!cliPath || !existsSync(cliPath))
-        return null;
-    const args = ["system", "reload", ...extraArgs];
-    if (cliPath.endsWith(".js")) {
-        return {
-            command: process.execPath,
-            args: [cliPath, ...args],
-            displayCommand: buildSudoDisplayCommand(process.execPath, [cliPath, ...args]),
-        };
-    }
-    return {
-        command: cliPath,
-        args,
-        displayCommand: buildSudoDisplayCommand(cliPath, args),
-    };
-}
-function resolveSystemReloadTarget(options = {}) {
-    const extraArgs = options.restartInstances ? ["--restart-instances"] : [];
-    const wrapper = getSystemReloadWrapper();
-    if (existsSync(wrapper)) {
-        return {
-            command: wrapper,
-            args: ["system", "reload", ...extraArgs],
-            displayCommand: buildSudoDisplayCommand(wrapper, ["system", "reload", ...extraArgs]),
-        };
-    }
-    return resolveCurrentCliTarget(process.env.JISHUSHELL_CORE_BIN, extraArgs)
-        ?? resolveCurrentCliTarget(process.argv[1], extraArgs);
-}
-function getSystemReloadCommand() {
-    return resolveSystemReloadTarget()?.displayCommand
-        ?? buildSudoDisplayCommand(getSystemReloadWrapper(), ["system", "reload"]);
-}
-function readStoredReconcileState() {
-    if (!existsSync(RECONCILE_STATE_FILE))
-        return null;
-    try {
-        return JSON.parse(readFileSync(RECONCILE_STATE_FILE, "utf-8"));
-    }
-    catch {
-        return null;
-    }
-}
-function createSystemReloadSudoError(result) {
-    const message = (result.stderr || result.stdout).trim();
-    if (isSudoAuthenticationError(message)) {
-        return createInvalidSudoPasswordError();
-    }
-    if (isSudoNoNewPrivilegesError(message)) {
-        const err = new Error("当前运行环境禁止 sudo 提权（no new privileges），请在系统终端执行推荐的 reload 命令。");
-        err.code = "SUDO_NO_NEW_PRIVILEGES";
-        return err;
-    }
-    if (/systemd-run.*not found|No such file or directory/i.test(message)) {
-        const err = new Error("当前系统缺少 systemd-run，无法从网页安全启动后台 reload。请在系统终端执行推荐命令。");
-        err.code = "SYSTEM_RELOAD_UNSUPPORTED";
-        return err;
-    }
-    if (message)
-        return new Error(message);
-    return new Error("无法启动系统 reload，请在系统终端执行推荐命令。");
-}
-function buildSystemdRunReloadArgs(unit, includeCollect, target) {
-    const currentUser = userInfo();
-    const sudoEnv = typeof process.getuid === "function" && process.getuid() > 0
-        ? [
-            `--setenv=SUDO_UID=${process.getuid()}`,
-            ...(typeof process.getgid === "function" ? [`--setenv=SUDO_GID=${process.getgid()}`] : []),
-            `--setenv=SUDO_USER=${currentUser.username}`,
-        ]
-        : [];
-    const args = [
-        "systemd-run",
-        "--quiet",
-        `--unit=${unit}`,
-        `--setenv=JISHUSHELL_HOME=${JISHUSHELL_HOME}`,
-        `--setenv=HOME=${dirname(JISHUSHELL_HOME)}`,
-        ...sudoEnv,
-        target.command,
-        ...target.args,
-    ];
-    if (includeCollect)
-        args.splice(2, 0, "--collect");
-    return args;
-}
-function normalizeText(content) {
-    return content
-        .replace(/\r\n/g, "\n")
-        .replace(/\r/g, "\n")
-        .split("\n")
-        .map((line) => line.trimEnd())
-        .join("\n")
-        .replace(/\n*$/, "\n");
-}
-function hashText(content) {
-    return createHash("sha256").update(normalizeText(content)).digest("hex");
-}
-function readActualFile(path, sudoAvailable) {
-    try {
-        return { content: readFileSync(path, "utf-8") };
-    }
-    catch (e) {
-        if (e?.code === "ENOENT")
-            return { content: null };
-        if (e?.code === "EACCES" && sudoAvailable) {
-            try {
-                return { content: execFileSync("sudo", ["-n", "cat", path], { encoding: "utf-8", timeout: 3000 }) };
-            }
-            catch (sudoError) {
-                return { content: null, error: sudoError?.message || String(sudoError), errorCode: sudoError?.code };
-            }
-        }
-        return { content: null, error: e?.message || String(e), errorCode: e?.code };
-    }
-}
-function checkExpectedFile(resource, sudoAvailable) {
-    let isSymlink = false;
-    try {
-        isSymlink = lstatSync(resource.path).isSymbolicLink();
-    }
-    catch (e) {
-        if (e?.code !== "ENOENT") {
-            return {
-                resource,
-                drift: true,
-                missing: false,
-                expectedHash: hashText(resource.content),
-                error: e?.message || String(e),
-                errorCode: e?.code,
-            };
-        }
-    }
-    const actual = readActualFile(resource.path, sudoAvailable);
-    const expectedHash = hashText(resource.content);
-    if (actual.error) {
-        return {
-            resource,
-            drift: true,
-            missing: false,
-            expectedHash,
-            error: actual.error,
-            errorCode: actual.errorCode,
-        };
-    }
-    if (actual.content === null) {
-        return {
-            resource,
-            drift: true,
-            missing: true,
-            expectedHash,
-        };
-    }
-    const actualHash = hashText(actual.content);
-    return {
-        resource,
-        drift: expectedHash !== actualHash || isSymlink,
-        missing: false,
-        expectedHash,
-        actualHash,
-        isSymlink,
-    };
-}
-function statusForDrift(check, sudoAvailable) {
-    if (!check.drift)
-        return "ok";
-    if (check.error)
-        return check.errorCode === "EACCES" && !sudoAvailable ? "skipped" : "error";
-    if (check.resource.requiresSudo && !sudoAvailable)
-        return "skipped";
-    return "skipped";
-}
-function requiresOperatorReload(resource, sudoAvailable) {
-    if (!resource.reloadRequired)
-        return false;
-    if (resource.requiresSudo && !sudoAvailable)
-        return true;
-    return !sudoAvailable && process.platform !== "darwin";
-}
-function buildFileItem(check, sudoAvailable) {
-    const resource = check.resource;
-    if (!check.drift) {
-        return {
-            component: resource.id,
-            id: resource.id,
-            path: resource.path,
-            status: "ok",
-            message: `${resource.path} matches expected ${resource.component} state`,
-            requiresSudo: false,
-            reloadRequired: false,
-            manualRequired: false,
-            fix: "none",
-            expectedHash: check.expectedHash,
-            actualHash: check.actualHash,
-            severity: "info",
-        };
-    }
-    const manualRequired = requiresOperatorReload(resource, sudoAvailable);
-    const status = statusForDrift(check, sudoAvailable);
-    const missingOrDifferent = check.missing
-        ? "is missing"
-        : check.isSymlink
-            ? "is a symlink; expected a managed file"
-            : "differs from expected state";
-    const message = check.error
-        ? `Cannot read ${resource.path}: ${check.error}`
-        : `${resource.path} ${missingOrDifferent}`;
-    return {
-        component: resource.id,
-        id: resource.id,
-        path: resource.path,
-        status,
-        message,
-        requiresSudo: resource.requiresSudo || manualRequired,
-        reloadRequired: resource.reloadRequired,
-        manualRequired,
-        fix: resource.fix,
-        command: resource.reloadRequired ? getSystemReloadCommand() : undefined,
-        expectedHash: check.expectedHash,
-        actualHash: check.actualHash,
-        details: check.error,
-        severity: status === "error" ? "error" : "warning",
-    };
-}
-function applyScope(scope, corePort) {
-    switch (scope) {
-        case "core":
-            return setupManager.installJishushellSystemd(corePort, false);
-        case "panel":
-            return setupManager.installJishushellPanelSystemd(corePort, undefined, false);
-        case "nomad":
-            return setupManager.installNomadSystemd();
-    }
-}
-function groupedByScope(checks) {
-    const groups = new Map();
-    for (const check of checks) {
-        const existing = groups.get(check.resource.installScope) ?? [];
-        existing.push(check);
-        groups.set(check.resource.installScope, existing);
-    }
-    return groups;
-}
-function scopeRequiresSudo(scope, checks) {
-    if (process.platform === "darwin") {
-        return checks.some((check) => check.resource.requiresSudo);
-    }
-    return scope === "core" || scope === "panel" || scope === "nomad";
-}
-function pushAppliedScopeResult(items, scope, checks, result) {
-    const ids = checks.map((check) => check.resource.id);
-    const reloadRequired = checks.some((check) => check.resource.reloadRequired);
-    if (!result.ok) {
-        items.push({
-            component: `${scope}.expected-state`,
-            status: "error",
-            message: result.message,
-            requiresSudo: checks.some((check) => check.resource.requiresSudo),
-            reloadRequired,
-            manualRequired: true,
-            fix: reloadRequired ? "system-reload" : "manual",
-            command: reloadRequired ? getSystemReloadCommand() : undefined,
-            details: [result.error, `Resources: ${ids.join(", ")}`].filter(Boolean).join("\n"),
-            severity: "error",
-        });
-        return;
-    }
-    const postChecks = checks.map((check) => checkExpectedFile(check.resource, true));
-    const remaining = postChecks.filter((check) => check.drift);
-    if (remaining.length > 0) {
-        items.push({
-            component: `${scope}.expected-state`,
-            status: "error",
-            message: `${scope} installer completed but ${remaining.length} resource(s) still drift`,
-            requiresSudo: checks.some((check) => check.resource.requiresSudo),
-            reloadRequired,
-            manualRequired: true,
-            fix: reloadRequired ? "system-reload" : "manual",
-            command: reloadRequired ? getSystemReloadCommand() : undefined,
-            details: remaining.map((check) => `${check.resource.id}: ${check.resource.path}`).join("\n"),
-            severity: "error",
-        });
-        return;
-    }
-    items.push({
-        component: `${scope}.expected-state`,
-        status: "updated",
-        message: result.message,
-        requiresSudo: false,
-        reloadRequired,
-        manualRequired: false,
-        fix: reloadRequired ? "system-reload" : "none",
-        command: reloadRequired ? getSystemReloadCommand() : undefined,
-        details: `Resources: ${ids.join(", ")}`,
-        severity: "info",
-    });
-}
-function reconcileExpectedFiles(items, options, sudoAvailable) {
-    const corePort = getCorePort();
-    let files;
-    try {
-        files = setupManager.getExpectedSystemFiles({ corePort });
-    }
-    catch (e) {
-        items.push({
-            component: "expected-state",
-            status: "error",
-            message: "Failed to render expected system state",
-            manualRequired: true,
-            fix: "manual",
-            details: e?.message || String(e),
-            severity: "error",
-        });
-        return;
-    }
-    const checks = files.map((file) => checkExpectedFile(file, sudoAvailable));
-    const clean = checks.filter((check) => !check.drift);
-    for (const check of clean) {
-        items.push(buildFileItem(check, sudoAvailable));
-    }
-    const drifted = checks.filter((check) => check.drift);
-    if (drifted.length === 0)
-        return;
-    if (!options.apply) {
-        for (const check of drifted) {
-            items.push(buildFileItem(check, sudoAvailable));
-        }
-        return;
-    }
-    const groups = groupedByScope(drifted);
-    for (const [scope, scopedChecks] of groups) {
-        const requiresSudo = scopeRequiresSudo(scope, scopedChecks);
-        if (requiresSudo && !sudoAvailable) {
-            for (const check of scopedChecks) {
-                items.push(buildFileItem(check, sudoAvailable));
-            }
-            continue;
-        }
-        const result = applyScope(scope, corePort);
-        pushAppliedScopeResult(items, scope, scopedChecks, result);
-    }
-}
-// ── Reconcile: Docker images ───────────────────────────────────────────────
-async function reconcileDockerImages(results, apply) {
-    const config = getCoreConfig();
-    if (config.service_manager !== "nomad") {
-        results.push({
-            component: "docker-images",
-            status: "skipped",
-            message: "Not using Nomad/Docker runtime",
-            reloadRequired: false,
-            manualRequired: false,
-            fix: "none",
-            severity: "info",
-        });
-        return;
-    }
-    try {
-        execFileSync("docker", ["info"], { stdio: "ignore", timeout: 8000 });
-    }
-    catch (e) {
-        results.push({
-            component: "docker-images",
-            status: "skipped",
-            message: "Docker not available",
-            reloadRequired: false,
-            manualRequired: true,
-            fix: "manual",
-            severity: "warning",
-            details: e?.message || "Cannot connect to Docker daemon. Ensure Docker is installed and running.",
-        });
-        return;
-    }
-    for (const adapter of listRegisteredAdapters()) {
-        const catalogEntry = getRuntimeCatalogEntry(adapter.agentType);
-        const expectedImage = catalogEntry?.image || catalogEntry?.defaultImage;
-        if (!expectedImage)
-            continue;
-        try {
-            execFileSync("docker", ["image", "inspect", expectedImage], { timeout: 10000, stdio: "ignore" });
-            results.push({
-                component: `docker.${adapter.agentType}`,
-                id: expectedImage,
-                status: "ok",
-                message: `Image ${expectedImage} present`,
-                reloadRequired: false,
-                manualRequired: false,
-                fix: "none",
-                severity: "info",
-            });
-        }
-        catch {
-            if (!apply) {
-                results.push({
-                    component: `docker.${adapter.agentType}`,
-                    id: expectedImage,
-                    status: "skipped",
-                    message: `Image ${expectedImage} missing`,
-                    reloadRequired: false,
-                    manualRequired: false,
-                    fix: "docker-pull",
-                    details: `Run: docker pull ${expectedImage}`,
-                    severity: "warning",
-                });
-                continue;
-            }
-            try {
-                execFileSync("docker", ["pull", expectedImage], { timeout: 120000, stdio: "ignore" });
-                results.push({
-                    component: `docker.${adapter.agentType}`,
-                    id: expectedImage,
-                    status: "updated",
-                    message: `Pulled image ${expectedImage}`,
-                    reloadRequired: false,
-                    manualRequired: false,
-                    fix: "none",
-                    severity: "info",
-                });
-            }
-            catch (e) {
-                results.push({
-                    component: `docker.${adapter.agentType}`,
-                    id: expectedImage,
-                    status: "error",
-                    message: `Failed to pull ${expectedImage}: ${e?.message || "timeout"}`,
-                    reloadRequired: false,
-                    manualRequired: true,
-                    fix: "docker-pull",
-                    details: "Check network connectivity and Docker permissions.",
-                    severity: "error",
-                });
-            }
-        }
-    }
-}
-// ── Main entry points ──────────────────────────────────────────────────────
-function persistResult(result) {
-    try {
-        ensureDirHost(JISHUSHELL_HOME);
-        writeFileSync(RECONCILE_STATE_FILE, `${JSON.stringify(result, null, 2)}\n`, "utf-8");
-        chownToServiceUser(RECONCILE_STATE_FILE);
-    }
-    catch { }
-}
-function emptyRuntimeState() {
-    return { restartRequired: false, instances: [] };
-}
-function normalizeRuntimeState(runtime) {
-    if (!runtime)
-        return emptyRuntimeState();
-    const instances = Array.isArray(runtime.instances)
-        ? runtime.instances.map((item) => ({
-            ...item,
-            id: item.id || LEGACY_JOB_SPEC_RESTART_ADVISORY_ID,
-        }))
-        : [];
-    return {
-        restartRequired: runtime.restartRequired || instances.length > 0,
-        instances,
-    };
-}
-function finalizeResult(items, sudoAvailable, runtime) {
-    const runtimeState = normalizeRuntimeState(runtime);
-    const hasPendingSudoActions = items.some((item) => item.requiresSudo && item.status !== "ok" && item.status !== "updated");
-    const reloadRequired = items.some((item) => item.reloadRequired && item.status !== "ok");
-    const manualRequired = hasPendingSudoActions || items.some((item) => item.manualRequired && item.status !== "ok" && item.status !== "updated");
-    return {
-        timestamp: new Date().toISOString(),
-        items,
-        runtime: runtimeState,
-        hasPendingSudoActions,
-        reloadRequired,
-        runtimeRestartRequired: runtimeState.restartRequired,
-        manualRequired,
-        canAutoReload: reloadRequired && !manualRequired && sudoAvailable,
-        command: getSystemReloadCommand(),
-    };
-}
-async function runSystemReconciliation(options, runtime) {
-    const items = [];
-    const sudoAvailable = hasSudoAccess();
-    const runtimeState = runtime ?? readStoredReconcileState()?.runtime;
-    reconcileExpectedFiles(items, options, sudoAvailable);
-    await reconcileDockerImages(items, options.apply);
-    const result = finalizeResult(items, sudoAvailable, runtimeState);
-    persistResult(result);
-    return result;
-}
-export async function inspectSystemDrift() {
-    return runSystemReconciliation({ apply: false });
-}
-export async function reconcileSystem() {
-    return runSystemReconciliation({ apply: true });
-}
-export async function persistRuntimeRestartAdvisories(instances) {
-    return inspectSystemDriftWithRuntime({
-        restartRequired: instances.length > 0,
-        instances,
-    });
-}
-export async function clearRuntimeRestartAdvisory(instanceId) {
-    const current = readStoredReconcileState();
-    if (!current?.runtime?.instances?.length)
-        return current;
-    const instances = current.runtime.instances.filter((item) => item.instanceId !== instanceId);
-    const next = {
-        ...current,
-        timestamp: new Date().toISOString(),
-        runtime: { restartRequired: instances.length > 0, instances },
-        runtimeRestartRequired: instances.length > 0,
-    };
-    persistResult(next);
-    return next;
-}
-export async function acknowledgeRuntimeRestartAdvisory(instanceId) {
-    const current = readStoredReconcileState();
-    const advisories = current?.runtime?.instances?.filter((item) => item.instanceId === instanceId) ?? [];
-    for (const advisory of advisories) {
-        markRuntimeRestartAdvisoryApplied(instanceId, advisory.id || LEGACY_JOB_SPEC_RESTART_ADVISORY_ID);
-    }
-    return clearRuntimeRestartAdvisory(instanceId);
-}
-async function inspectSystemDriftWithRuntime(runtime) {
-    return runSystemReconciliation({ apply: false }, runtime);
-}
-export async function startSystemReloadWithSudo(sudoPassword, options = {}) {
-    if (!sudoPassword) {
-        throw new Error("请输入 sudo 密码");
-    }
-    if (process.platform === "darwin") {
-        const err = new Error("macOS 暂不支持从网页执行系统 reload，请在终端执行推荐命令。");
-        err.code = "SYSTEM_RELOAD_UNSUPPORTED";
-        throw err;
-    }
-    const target = resolveSystemReloadTarget(options);
-    if (!target) {
-        throw new Error(`找不到可执行的 JishuShell reload 命令：${getSystemReloadWrapper()}`);
-    }
-    const unit = `jishushell-web-reload-${process.pid}-${Date.now()}`;
-    let result = await runSudoAskpassCommand(sudoPassword, buildSystemdRunReloadArgs(unit, true, target), { timeoutMs: 20_000 });
-    if (result.code !== 0 && /(?:unrecognized|unknown|invalid) option.*collect|collect.*(?:unrecognized|unknown|invalid)/i.test(result.stderr)) {
-        result = await runSudoAskpassCommand(sudoPassword, buildSystemdRunReloadArgs(unit, false, target), { timeoutMs: 20_000 });
-    }
-    if (result.code !== 0) {
-        throw createSystemReloadSudoError(result);
-    }
-    return {
-        accepted: true,
-        command: target.displayCommand,
-        message: "系统 reload 已在后台启动，服务会短暂重启。",
-        state: readStoredReconcileState(),
-        unit,
-    };
-}
-//# sourceMappingURL=system-reconciler.js.map