@nextclaw/service 0.1.1

package/dist/commands/service/services/autostart/host-autostart-runtime.service.js

@@ -0,0 +1,53 @@
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+import { extname, isAbsolute, resolve, win32 } from "node:path";
+import { getDataDir } from "@nextclaw/core";
+//#region src/commands/service/services/autostart/host-autostart-runtime.service.ts
+const TYPESCRIPT_EXTENSIONS = new Set([
+	".ts",
+	".tsx",
+	".mts",
+	".cts"
+]);
+const require = createRequire(import.meta.url);
+const resolveCliAppEntryFromImportMeta = (importMetaUrl) => {
+	const modulePath = fileURLToPath(importMetaUrl);
+	const cliRootIndex = modulePath.replace(/\\/g, "/").lastIndexOf("/cli/");
+	if (cliRootIndex === -1) return fileURLToPath(new URL("../../../app/index.js", importMetaUrl));
+	const extension = extname(modulePath) || ".js";
+	return resolve(modulePath.slice(0, cliRootIndex + 5), "app", `index${extension}`);
+};
+var HostAutostartRuntimeService = class {
+	nodePath;
+	argvEntry;
+	importMetaUrl;
+	getResolvedDataDir;
+	constructor(options = {}) {
+		this.nodePath = options.nodePath ?? process.execPath;
+		this.argvEntry = options.argvEntry ?? process.argv[1];
+		this.importMetaUrl = options.importMetaUrl ?? import.meta.url;
+		this.getResolvedDataDir = options.getDataDir ?? getDataDir;
+	}
+	resolveForegroundServeLaunch = () => {
+		const cliEntry = this.resolveCliEntry();
+		return {
+			homeDir: this.getResolvedDataDir(),
+			command: this.nodePath,
+			args: TYPESCRIPT_EXTENSIONS.has(extname(cliEntry).toLowerCase()) ? [
+				require.resolve("tsx/cli"),
+				cliEntry,
+				"serve"
+			] : [cliEntry, "serve"]
+		};
+	};
+	resolveCliEntry = () => {
+		const argvEntry = this.argvEntry?.trim();
+		if (argvEntry) {
+			if (isAbsolute(argvEntry) || win32.isAbsolute(argvEntry)) return argvEntry;
+			return resolve(argvEntry);
+		}
+		return resolveCliAppEntryFromImportMeta(this.importMetaUrl);
+	};
+};
+//#endregion
+export { HostAutostartRuntimeService };

package/dist/commands/service/services/autostart/host-autostart.service.d.ts

@@ -0,0 +1,41 @@
+import { HostAutostartDoctorReport, HostAutostartInstallResult, HostAutostartScope, HostAutostartStatus, HostAutostartUninstallResult } from "../../types/autostart/host-autostart.types.js";
+import { LinuxSystemdAutostartService } from "./linux-systemd-autostart.service.js";
+import { MacosLaunchAgentAutostartService } from "./macos-launch-agent-autostart.service.js";
+import { WindowsTaskAutostartService } from "./windows-task-autostart.service.js";
+
+//#region src/commands/service/services/autostart/host-autostart.service.d.ts
+type HostAutostartServiceOptions = {
+  linuxSystemdService?: LinuxSystemdAutostartService;
+  macosLaunchAgentService?: MacosLaunchAgentAutostartService;
+  windowsTaskService?: WindowsTaskAutostartService;
+  platform?: NodeJS.Platform;
+};
+declare class HostAutostartService {
+  private readonly platform;
+  private readonly linuxSystemdService;
+  private readonly macosLaunchAgentService;
+  private readonly windowsTaskService;
+  constructor(options?: HostAutostartServiceOptions);
+  installSystemd: (scope: HostAutostartScope, options?: {
+    dryRun?: boolean;
+  }) => Promise<HostAutostartInstallResult>;
+  uninstallSystemd: (scope: HostAutostartScope, options?: {
+    dryRun?: boolean;
+  }) => Promise<HostAutostartUninstallResult>;
+  installLaunchAgent: (options?: {
+    dryRun?: boolean;
+  }) => Promise<HostAutostartInstallResult>;
+  uninstallLaunchAgent: (options?: {
+    dryRun?: boolean;
+  }) => Promise<HostAutostartUninstallResult>;
+  installWindowsTask: (options?: {
+    dryRun?: boolean;
+  }) => Promise<HostAutostartInstallResult>;
+  uninstallWindowsTask: (options?: {
+    dryRun?: boolean;
+  }) => Promise<HostAutostartUninstallResult>;
+  status: (scope?: HostAutostartScope) => Promise<HostAutostartStatus>;
+  doctor: (scope?: HostAutostartScope) => Promise<HostAutostartDoctorReport>;
+}
+//#endregion
+export { HostAutostartService };

package/dist/commands/service/services/autostart/host-autostart.service.js

@@ -0,0 +1,48 @@
+import { LinuxSystemdAutostartService } from "./linux-systemd-autostart.service.js";
+import { MacosLaunchAgentAutostartService } from "./macos-launch-agent-autostart.service.js";
+import { WindowsTaskAutostartService } from "./windows-task-autostart.service.js";
+//#region src/commands/service/services/autostart/host-autostart.service.ts
+var HostAutostartService = class {
+	platform;
+	linuxSystemdService;
+	macosLaunchAgentService;
+	windowsTaskService;
+	constructor(options = {}) {
+		this.platform = options.platform ?? process.platform;
+		this.linuxSystemdService = options.linuxSystemdService ?? new LinuxSystemdAutostartService();
+		this.macosLaunchAgentService = options.macosLaunchAgentService ?? new MacosLaunchAgentAutostartService();
+		this.windowsTaskService = options.windowsTaskService ?? new WindowsTaskAutostartService();
+	}
+	installSystemd = async (scope, options = {}) => {
+		return await this.linuxSystemdService.install(scope, options);
+	};
+	uninstallSystemd = async (scope, options = {}) => {
+		return await this.linuxSystemdService.uninstall(scope, options);
+	};
+	installLaunchAgent = async (options = {}) => {
+		return await this.macosLaunchAgentService.install("user", options);
+	};
+	uninstallLaunchAgent = async (options = {}) => {
+		return await this.macosLaunchAgentService.uninstall("user", options);
+	};
+	installWindowsTask = async (options = {}) => {
+		return await this.windowsTaskService.install("user", options);
+	};
+	uninstallWindowsTask = async (options = {}) => {
+		return await this.windowsTaskService.uninstall("user", options);
+	};
+	status = async (scope) => {
+		if (this.platform === "linux") return await this.linuxSystemdService.status(scope);
+		if (this.platform === "darwin") return await this.macosLaunchAgentService.status(scope);
+		if (this.platform === "win32") return await this.windowsTaskService.status(scope);
+		return await this.linuxSystemdService.status(scope);
+	};
+	doctor = async (scope) => {
+		if (this.platform === "linux") return await this.linuxSystemdService.doctor(scope);
+		if (this.platform === "darwin") return await this.macosLaunchAgentService.doctor(scope);
+		if (this.platform === "win32") return await this.windowsTaskService.doctor(scope);
+		return await this.linuxSystemdService.doctor(scope);
+	};
+};
+//#endregion
+export { HostAutostartService };

package/dist/commands/service/services/autostart/linux-systemd-autostart.service.d.ts

@@ -0,0 +1,48 @@
+import { HostAutostartDoctorReport, HostAutostartInstallResult, HostAutostartRunCommand, HostAutostartScope, HostAutostartStatus, HostAutostartUninstallResult } from "../../types/autostart/host-autostart.types.js";
+import { HostAutostartRuntimeService } from "./host-autostart-runtime.service.js";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+
+//#region src/commands/service/services/autostart/linux-systemd-autostart.service.d.ts
+type LinuxSystemdAutostartServiceOptions = {
+  platform?: NodeJS.Platform;
+  env?: NodeJS.ProcessEnv;
+  getHomeDir?: () => string;
+  existsSync?: (path: string) => boolean;
+  mkdirSync?: typeof mkdirSync;
+  writeFileSync?: typeof writeFileSync;
+  rmSync?: typeof rmSync;
+  runCommand?: HostAutostartRunCommand;
+  runtimeService?: HostAutostartRuntimeService;
+};
+declare class LinuxSystemdAutostartService {
+  private readonly platform;
+  private readonly env;
+  private readonly getHomeDir;
+  private readonly pathExists;
+  private readonly ensureDir;
+  private readonly writeFile;
+  private readonly removeFile;
+  private readonly runCommandImpl;
+  private readonly runtimeService;
+  constructor(options?: LinuxSystemdAutostartServiceOptions);
+  install: (scope: HostAutostartScope, options?: {
+    dryRun?: boolean;
+  }) => Promise<HostAutostartInstallResult>;
+  uninstall: (scope: HostAutostartScope, options?: {
+    dryRun?: boolean;
+  }) => Promise<HostAutostartUninstallResult>;
+  status: (requestedScope?: HostAutostartScope) => Promise<HostAutostartStatus>;
+  doctor: (requestedScope?: HostAutostartScope) => Promise<HostAutostartDoctorReport>;
+  private isSupported;
+  private getUnsupportedReason;
+  private createUnsupportedStatus;
+  private createUnsupportedInstallResult;
+  private resolveScopeForRead;
+  private buildPlan;
+  private getUnitPath;
+  private escapeSystemdValue;
+  private formatCommand;
+  private runCheckedCommand;
+}
+//#endregion
+export { LinuxSystemdAutostartService };

package/dist/commands/service/services/autostart/linux-systemd-autostart.service.js

@@ -0,0 +1,433 @@
+import { HostAutostartRuntimeService } from "./host-autostart-runtime.service.js";
+import { spawn } from "node:child_process";
+import { dirname, join, resolve } from "node:path";
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+//#region src/commands/service/services/autostart/linux-systemd-autostart.service.ts
+const DEFAULT_SYSTEMD_SERVICE_NAME = "nextclaw.service";
+const SUPPORTED_PLATFORM = "linux";
+var LinuxSystemdAutostartService = class {
+	platform;
+	env;
+	getHomeDir;
+	pathExists;
+	ensureDir;
+	writeFile;
+	removeFile;
+	runCommandImpl;
+	runtimeService;
+	constructor(options = {}) {
+		this.platform = options.platform ?? process.platform;
+		this.env = options.env ?? process.env;
+		this.getHomeDir = options.getHomeDir ?? homedir;
+		this.pathExists = options.existsSync ?? existsSync;
+		this.ensureDir = options.mkdirSync ?? mkdirSync;
+		this.writeFile = options.writeFileSync ?? writeFileSync;
+		this.removeFile = options.rmSync ?? rmSync;
+		this.runCommandImpl = options.runCommand ?? defaultRunCommand;
+		this.runtimeService = options.runtimeService ?? new HostAutostartRuntimeService();
+	}
+	install = async (scope, options = {}) => {
+		if (!this.isSupported()) return this.createUnsupportedInstallResult(scope, Boolean(options.dryRun));
+		const plan = this.buildPlan(scope);
+		const actions = [
+			`write unit file ${plan.resourcePath}`,
+			`run ${this.formatCommand(plan.systemctlCommand, [...plan.systemctlScopeArgs, "daemon-reload"])}`,
+			`run ${this.formatCommand(plan.systemctlCommand, [
+				...plan.systemctlScopeArgs,
+				"enable",
+				plan.resourceName
+			])}`,
+			`run ${this.formatCommand(plan.systemctlCommand, [
+				...plan.systemctlScopeArgs,
+				"restart",
+				plan.resourceName
+			])}`
+		];
+		try {
+			if (!options.dryRun) {
+				this.ensureDir(dirname(plan.resourcePath), { recursive: true });
+				this.writeFile(plan.resourcePath, plan.unitContent);
+				await this.runCheckedCommand({
+					command: plan.systemctlCommand,
+					args: [...plan.systemctlScopeArgs, "daemon-reload"]
+				});
+				await this.runCheckedCommand({
+					command: plan.systemctlCommand,
+					args: [
+						...plan.systemctlScopeArgs,
+						"enable",
+						plan.resourceName
+					]
+				});
+				await this.runCheckedCommand({
+					command: plan.systemctlCommand,
+					args: [
+						...plan.systemctlScopeArgs,
+						"restart",
+						plan.resourceName
+					]
+				});
+			}
+		} catch (error) {
+			return {
+				ok: false,
+				dryRun: Boolean(options.dryRun),
+				scope,
+				hostOwner: plan.hostOwner,
+				resourceName: plan.resourceName,
+				resourcePath: plan.resourcePath,
+				homeDir: plan.homeDir,
+				command: plan.command,
+				logHint: plan.logHint,
+				actions,
+				reasonIfUnavailable: error instanceof Error ? error.message : "systemd autostart install failed."
+			};
+		}
+		return {
+			ok: true,
+			dryRun: Boolean(options.dryRun),
+			scope,
+			hostOwner: plan.hostOwner,
+			resourceName: plan.resourceName,
+			resourcePath: plan.resourcePath,
+			homeDir: plan.homeDir,
+			command: plan.command,
+			logHint: plan.logHint,
+			actions,
+			reasonIfUnavailable: null
+		};
+	};
+	uninstall = async (scope, options = {}) => {
+		const plan = this.buildPlan(scope);
+		if (!this.isSupported()) return {
+			ok: false,
+			dryRun: Boolean(options.dryRun),
+			scope,
+			hostOwner: plan.hostOwner,
+			resourceName: plan.resourceName,
+			resourcePath: plan.resourcePath,
+			removed: false,
+			logHint: plan.logHint,
+			actions: [],
+			reasonIfUnavailable: this.getUnsupportedReason()
+		};
+		const installed = this.pathExists(plan.resourcePath);
+		const actions = [];
+		if (!installed) return {
+			ok: true,
+			dryRun: Boolean(options.dryRun),
+			scope,
+			hostOwner: plan.hostOwner,
+			resourceName: plan.resourceName,
+			resourcePath: plan.resourcePath,
+			removed: false,
+			logHint: plan.logHint,
+			actions: ["no installed unit file found"],
+			reasonIfUnavailable: null
+		};
+		actions.push(`run ${this.formatCommand(plan.systemctlCommand, [
+			...plan.systemctlScopeArgs,
+			"disable",
+			"--now",
+			plan.resourceName
+		])}`);
+		actions.push(`remove unit file ${plan.resourcePath}`);
+		actions.push(`run ${this.formatCommand(plan.systemctlCommand, [...plan.systemctlScopeArgs, "daemon-reload"])}`);
+		try {
+			if (!options.dryRun) {
+				await this.runCheckedCommand({
+					command: plan.systemctlCommand,
+					args: [
+						...plan.systemctlScopeArgs,
+						"disable",
+						"--now",
+						plan.resourceName
+					]
+				});
+				this.removeFile(plan.resourcePath, { force: true });
+				await this.runCheckedCommand({
+					command: plan.systemctlCommand,
+					args: [...plan.systemctlScopeArgs, "daemon-reload"]
+				});
+			}
+		} catch (error) {
+			return {
+				ok: false,
+				dryRun: Boolean(options.dryRun),
+				scope,
+				hostOwner: plan.hostOwner,
+				resourceName: plan.resourceName,
+				resourcePath: plan.resourcePath,
+				removed: false,
+				logHint: plan.logHint,
+				actions,
+				reasonIfUnavailable: error instanceof Error ? error.message : "systemd autostart uninstall failed."
+			};
+		}
+		return {
+			ok: true,
+			dryRun: Boolean(options.dryRun),
+			scope,
+			hostOwner: plan.hostOwner,
+			resourceName: plan.resourceName,
+			resourcePath: plan.resourcePath,
+			removed: true,
+			logHint: plan.logHint,
+			actions,
+			reasonIfUnavailable: null
+		};
+	};
+	status = async (requestedScope) => {
+		if (!this.isSupported()) return this.createUnsupportedStatus();
+		const resolvedScope = this.resolveScopeForRead(requestedScope);
+		if (!resolvedScope.scope) return {
+			supported: true,
+			installed: false,
+			enabled: null,
+			active: null,
+			scope: null,
+			hostOwner: null,
+			resourceName: null,
+			resourcePath: null,
+			homeDir: null,
+			command: null,
+			logHint: null,
+			reasonIfUnavailable: resolvedScope.reasonIfUnavailable
+		};
+		const plan = this.buildPlan(resolvedScope.scope);
+		if (!this.pathExists(plan.resourcePath)) return {
+			supported: true,
+			installed: false,
+			enabled: false,
+			active: false,
+			scope: resolvedScope.scope,
+			hostOwner: plan.hostOwner,
+			resourceName: plan.resourceName,
+			resourcePath: plan.resourcePath,
+			homeDir: plan.homeDir,
+			command: plan.command,
+			logHint: plan.logHint,
+			reasonIfUnavailable: null
+		};
+		const enabledResult = await this.runCommandImpl(plan.systemctlCommand, [
+			...plan.systemctlScopeArgs,
+			"is-enabled",
+			plan.resourceName
+		]);
+		const activeResult = await this.runCommandImpl(plan.systemctlCommand, [
+			...plan.systemctlScopeArgs,
+			"is-active",
+			plan.resourceName
+		]);
+		return {
+			supported: true,
+			installed: true,
+			enabled: enabledResult.code === 0,
+			active: activeResult.code === 0,
+			scope: resolvedScope.scope,
+			hostOwner: plan.hostOwner,
+			resourceName: plan.resourceName,
+			resourcePath: plan.resourcePath,
+			homeDir: plan.homeDir,
+			command: plan.command,
+			logHint: plan.logHint,
+			reasonIfUnavailable: null
+		};
+	};
+	doctor = async (requestedScope) => {
+		const status = await this.status(requestedScope);
+		const checks = [];
+		const launchPlan = this.runtimeService.resolveForegroundServeLaunch();
+		checks.push({
+			name: "platform",
+			status: status.supported ? "pass" : "fail",
+			detail: status.supported ? "linux supported" : status.reasonIfUnavailable ?? "unsupported platform"
+		});
+		checks.push({
+			name: "unit-file",
+			status: status.installed ? "pass" : "warn",
+			detail: status.resourcePath ?? "no unit path"
+		});
+		checks.push({
+			name: "exec-path",
+			status: this.pathExists(launchPlan.command) ? "pass" : "fail",
+			detail: launchPlan.command
+		});
+		checks.push({
+			name: "home-dir",
+			status: this.pathExists(launchPlan.homeDir) ? "pass" : "warn",
+			detail: launchPlan.homeDir
+		});
+		if (status.installed) {
+			checks.push({
+				name: "enabled",
+				status: status.enabled ? "pass" : "warn",
+				detail: status.enabled ? "systemd unit enabled" : "systemd unit not enabled"
+			});
+			checks.push({
+				name: "active",
+				status: status.active ? "pass" : "warn",
+				detail: status.active ? "systemd unit active" : "systemd unit not active"
+			});
+		}
+		return {
+			status,
+			checks,
+			exitCode: checks.some((check) => check.status === "fail") ? 1 : checks.some((check) => check.status === "warn") ? 1 : 0
+		};
+	};
+	isSupported = () => {
+		return this.platform === SUPPORTED_PLATFORM;
+	};
+	getUnsupportedReason = () => {
+		return "systemd autostart currently supports Linux only.";
+	};
+	createUnsupportedStatus = () => {
+		return {
+			supported: false,
+			installed: false,
+			enabled: null,
+			active: null,
+			scope: null,
+			hostOwner: null,
+			resourceName: null,
+			resourcePath: null,
+			homeDir: null,
+			command: null,
+			logHint: null,
+			reasonIfUnavailable: this.getUnsupportedReason()
+		};
+	};
+	createUnsupportedInstallResult = (scope, dryRun) => {
+		const plan = this.buildPlan(scope);
+		return {
+			ok: false,
+			dryRun,
+			scope,
+			hostOwner: plan.hostOwner,
+			resourceName: plan.resourceName,
+			resourcePath: plan.resourcePath,
+			homeDir: plan.homeDir,
+			command: plan.command,
+			logHint: plan.logHint,
+			actions: [],
+			reasonIfUnavailable: this.getUnsupportedReason()
+		};
+	};
+	resolveScopeForRead = (requestedScope) => {
+		if (requestedScope) return {
+			scope: requestedScope,
+			reasonIfUnavailable: null
+		};
+		const userInstalled = this.pathExists(this.getUnitPath("user"));
+		const systemInstalled = this.pathExists(this.getUnitPath("system"));
+		if (userInstalled && systemInstalled) return {
+			scope: null,
+			reasonIfUnavailable: "Both user and system units are installed. Re-run with --user or --system."
+		};
+		if (userInstalled) return {
+			scope: "user",
+			reasonIfUnavailable: null
+		};
+		if (systemInstalled) return {
+			scope: "system",
+			reasonIfUnavailable: null
+		};
+		return {
+			scope: "user",
+			reasonIfUnavailable: null
+		};
+	};
+	buildPlan = (scope) => {
+		const launch = this.runtimeService.resolveForegroundServeLaunch();
+		const command = this.formatCommand(launch.command, launch.args);
+		const resourceName = DEFAULT_SYSTEMD_SERVICE_NAME;
+		const resourcePath = this.getUnitPath(scope);
+		const homeDir = launch.homeDir;
+		const hostOwner = scope === "user" ? "systemd-user-service" : "systemd-system-service";
+		const systemctlScopeArgs = scope === "user" ? ["--user"] : [];
+		const logHint = scope === "user" ? `journalctl --user -u ${resourceName} -f` : `journalctl -u ${resourceName} -f`;
+		const wantedBy = scope === "user" ? "default.target" : "multi-user.target";
+		return {
+			scope,
+			resourceName,
+			resourcePath,
+			homeDir,
+			hostOwner,
+			command,
+			logHint,
+			unitContent: [
+				"[Unit]",
+				"Description=NextClaw managed local service",
+				"After=network-online.target",
+				"Wants=network-online.target",
+				"",
+				"[Service]",
+				"Type=simple",
+				`WorkingDirectory=${this.escapeSystemdValue(homeDir)}`,
+				`Environment=NEXTCLAW_HOME=${this.escapeSystemdValue(homeDir)}`,
+				`ExecStart=${command}`,
+				"Restart=on-failure",
+				"RestartSec=2",
+				"",
+				"[Install]",
+				`WantedBy=${wantedBy}`,
+				""
+			].join("\n"),
+			systemctlCommand: "systemctl",
+			systemctlScopeArgs
+		};
+	};
+	getUnitPath = (scope) => {
+		if (scope === "system") return "/etc/systemd/system/nextclaw.service";
+		return resolve(this.env.XDG_CONFIG_HOME?.trim() || join(this.getHomeDir(), ".config"), "systemd", "user", "nextclaw.service");
+	};
+	escapeSystemdValue = (value) => {
+		if (/^[A-Za-z0-9_./:@%+=,-]+$/.test(value)) return value;
+		return `"${value.replace(/(["\\])/g, "\\$1")}"`;
+	};
+	formatCommand = (command, args) => {
+		return [command, ...args].map((value) => this.escapeSystemdValue(value)).join(" ");
+	};
+	runCheckedCommand = async ({ command, args }) => {
+		const result = await this.runCommandImpl(command, args);
+		if (result.code === 0) return;
+		const detail = result.stderr || result.stdout || `exit code ${result.code}`;
+		throw new Error(`Command failed: ${this.formatCommand(command, args)} (${detail})`);
+	};
+};
+const defaultRunCommand = async (command, args) => {
+	return await new Promise((resolvePromise, rejectPromise) => {
+		const child = spawn(command, args, {
+			env: process.env,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		});
+		let stdout = "";
+		let stderr = "";
+		child.stdout?.setEncoding("utf-8");
+		child.stderr?.setEncoding("utf-8");
+		child.stdout?.on("data", (chunk) => {
+			stdout += chunk;
+		});
+		child.stderr?.on("data", (chunk) => {
+			stderr += chunk;
+		});
+		child.on("error", (error) => {
+			rejectPromise(error);
+		});
+		child.on("close", (code) => {
+			resolvePromise({
+				code: code ?? 1,
+				stdout: stdout.trim(),
+				stderr: stderr.trim()
+			});
+		});
+	});
+};
+//#endregion
+export { LinuxSystemdAutostartService };

package/dist/commands/service/services/autostart/macos-launch-agent-autostart.service.d.ts

@@ -0,0 +1,54 @@
+import { HostAutostartDoctorReport, HostAutostartInstallResult, HostAutostartRunCommand, HostAutostartScope, HostAutostartStatus, HostAutostartUninstallResult } from "../../types/autostart/host-autostart.types.js";
+import { HostAutostartRuntimeService } from "./host-autostart-runtime.service.js";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+
+//#region src/commands/service/services/autostart/macos-launch-agent-autostart.service.d.ts
+type MacosLaunchAgentAutostartServiceOptions = {
+  platform?: NodeJS.Platform;
+  env?: NodeJS.ProcessEnv;
+  getHomeDir?: () => string;
+  getUid?: () => number;
+  existsSync?: (path: string) => boolean;
+  mkdirSync?: typeof mkdirSync;
+  writeFileSync?: typeof writeFileSync;
+  rmSync?: typeof rmSync;
+  runCommand?: HostAutostartRunCommand;
+  runtimeService?: HostAutostartRuntimeService;
+};
+declare class MacosLaunchAgentAutostartService {
+  private readonly platform;
+  private readonly env;
+  private readonly getHomeDir;
+  private readonly getUid;
+  private readonly pathExists;
+  private readonly ensureDir;
+  private readonly writeFile;
+  private readonly removeFile;
+  private readonly runCommandImpl;
+  private readonly runtimeService;
+  constructor(options?: MacosLaunchAgentAutostartServiceOptions);
+  install: (scope: HostAutostartScope, options?: {
+    dryRun?: boolean;
+  }) => Promise<HostAutostartInstallResult>;
+  uninstall: (scope: HostAutostartScope, options?: {
+    dryRun?: boolean;
+  }) => Promise<HostAutostartUninstallResult>;
+  status: (requestedScope?: HostAutostartScope) => Promise<HostAutostartStatus>;
+  doctor: (requestedScope?: HostAutostartScope) => Promise<HostAutostartDoctorReport>;
+  private isSupported;
+  private createUnsupportedStatus;
+  private createUnsupportedInstallResult;
+  private createUnsupportedUninstallResult;
+  private buildPlan;
+  private renderPlist;
+  private escapeXml;
+  private escapeShellValue;
+  private formatCommand;
+  private hasGuiDomain;
+  private readEnabledState;
+  private escapeRegExp;
+  private runCheckedCommand;
+  private runTolerantCommand;
+}
+//#endregion
+export { MacosLaunchAgentAutostartService };