@nextclaw/service 0.1.1

package/dist/commands/remote/services/remote-runtime-support.service.d.ts

@@ -0,0 +1,15 @@
+import { Config } from "@nextclaw/core";
+import { RemoteConnector, RemoteLogger, RemotePlatformClient, RemoteRuntimeState, RemoteStatusSnapshot, RemoteStatusStore } from "@nextclaw/remote";
+
+//#region src/commands/remote/services/remote-runtime-support.service.d.ts
+declare function hasRunningNextclawManagedService(): boolean;
+declare function createNextclawRemotePlatformClient(): RemotePlatformClient;
+declare function createNextclawRemoteConnector(params?: {
+  logger?: RemoteLogger;
+}): RemoteConnector;
+declare function createNextclawRemoteStatusStore(mode: RemoteRuntimeState["mode"]): RemoteStatusStore;
+declare function buildNextclawConfiguredRemoteState(config: Config): RemoteRuntimeState;
+declare function readCurrentNextclawRemoteRuntimeState(): RemoteRuntimeState | null;
+declare function resolveNextclawRemoteStatusSnapshot(config: Config): RemoteStatusSnapshot;
+//#endregion
+export { buildNextclawConfiguredRemoteState, createNextclawRemoteConnector, createNextclawRemotePlatformClient, createNextclawRemoteStatusStore, hasRunningNextclawManagedService, readCurrentNextclawRemoteRuntimeState, resolveNextclawRemoteStatusSnapshot };

package/dist/commands/remote/services/remote-runtime-support.service.js

@@ -0,0 +1,79 @@
+import { getPackageVersion as getPackageVersion$1 } from "../../../shared/utils/package/package-manifest.utils.js";
+import { isProcessRunning } from "../../../shared/utils/cli.utils.js";
+import { localUiRuntimeStore } from "../../../shared/stores/local-ui-runtime.store.js";
+import { managedServiceStateStore } from "../../../shared/stores/managed-service-state.store.js";
+import { resolvePlatformApiBase } from "../utils/platform-api-base.utils.js";
+import { getConfigPath, getDataDir, loadConfig } from "@nextclaw/core";
+import { RemoteConnector, RemotePlatformClient, RemoteStatusStore, buildConfiguredRemoteState, resolveRemoteStatusSnapshot } from "@nextclaw/remote";
+//#region src/commands/remote/services/remote-runtime-support.service.ts
+let currentProcessRemoteRuntimeState = null;
+function hasRunningNextclawManagedService() {
+	const state = managedServiceStateStore.read();
+	return Boolean(state && isProcessRunning(state.pid));
+}
+function createNextclawRemotePlatformClient() {
+	return new RemotePlatformClient({
+		loadConfig: () => loadConfig(getConfigPath()),
+		getDataDir,
+		getPackageVersion: getPackageVersion$1,
+		resolvePlatformBase: (rawApiBase) => resolvePlatformApiBase({
+			explicitApiBase: rawApiBase,
+			requireConfigured: true
+		}).platformBase,
+		readManagedServiceState: () => {
+			const state = managedServiceStateStore.read();
+			if (!state) return null;
+			return {
+				pid: state.pid,
+				uiPort: state.uiPort
+			};
+		},
+		isProcessRunning
+	});
+}
+function createNextclawRemoteConnector(params = {}) {
+	return new RemoteConnector({
+		platformClient: createNextclawRemotePlatformClient(),
+		logger: params.logger
+	});
+}
+function createNextclawRemoteStatusStore(mode) {
+	return new RemoteStatusStore(mode, { writeRemoteState: (next) => {
+		currentProcessRemoteRuntimeState = next;
+		if (localUiRuntimeStore.read()?.pid === process.pid) localUiRuntimeStore.update((state) => ({
+			...state,
+			remote: next
+		}));
+		const serviceState = managedServiceStateStore.read();
+		if (!serviceState || serviceState.pid !== process.pid) return;
+		managedServiceStateStore.update((state) => ({
+			...state,
+			remote: next
+		}));
+	} });
+}
+function buildNextclawConfiguredRemoteState(config) {
+	return buildConfiguredRemoteState(config);
+}
+function readCurrentNextclawRemoteRuntimeState() {
+	const uiRuntimeState = localUiRuntimeStore.read();
+	const serviceState = managedServiceStateStore.read();
+	const currentRemoteState = currentProcessRemoteRuntimeState ?? uiRuntimeState?.remote ?? serviceState?.remote ?? null;
+	if (!currentRemoteState) return null;
+	const owningRuntime = uiRuntimeState ?? serviceState;
+	if (!owningRuntime || isProcessRunning(owningRuntime.pid)) return currentRemoteState;
+	return {
+		...currentRemoteState,
+		state: currentRemoteState.enabled ? "disconnected" : "disabled",
+		lastError: currentRemoteState.lastError ?? "Managed service is not running.",
+		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+}
+function resolveNextclawRemoteStatusSnapshot(config) {
+	return resolveRemoteStatusSnapshot({
+		config,
+		currentRemoteState: readCurrentNextclawRemoteRuntimeState()
+	});
+}
+//#endregion
+export { buildNextclawConfiguredRemoteState, createNextclawRemoteConnector, createNextclawRemotePlatformClient, createNextclawRemoteStatusStore, hasRunningNextclawManagedService, readCurrentNextclawRemoteRuntimeState, resolveNextclawRemoteStatusSnapshot };

package/dist/commands/remote/services/remote-service-control.service.d.ts

@@ -0,0 +1,33 @@
+import { resolveUiConfig } from "../../../shared/utils/cli.utils.js";
+import { RemoteServiceAction, RemoteServiceActionResult, RemoteServiceView } from "@nextclaw/server";
+
+//#region src/commands/remote/services/remote-service-control.service.d.ts
+type RemoteAccessHostServiceCommands = {
+  startService: (options: {
+    uiOverrides: Partial<ReturnType<typeof resolveUiConfig>>;
+    open: boolean;
+  }) => Promise<void>;
+  stopService: () => Promise<void>;
+};
+type RemoteRuntimeController = {
+  start: () => Promise<void> | null;
+  stop: () => Promise<void>;
+  restart: () => Promise<void>;
+};
+type CurrentUi = {
+  host: string;
+  port: number;
+};
+type RemoteServiceControlDeps = {
+  serviceCommands: RemoteAccessHostServiceCommands;
+  requestManagedServiceRestart: (options?: {
+    uiPort?: number;
+    reason?: string;
+  }) => Promise<void>;
+  currentUi?: CurrentUi;
+  remoteRuntimeController?: RemoteRuntimeController | null;
+};
+declare function resolveRemoteServiceView(currentUi?: CurrentUi): RemoteServiceView;
+declare function controlRemoteService(action: RemoteServiceAction, deps: RemoteServiceControlDeps): Promise<RemoteServiceActionResult>;
+//#endregion
+export { RemoteAccessHostServiceCommands, RemoteRuntimeController, controlRemoteService, resolveRemoteServiceView };

package/dist/commands/remote/services/remote-service-control.service.js

@@ -0,0 +1,188 @@
+import { isProcessRunning, resolveUiApiBase, resolveUiConfig } from "../../../shared/utils/cli.utils.js";
+import { managedServiceStateStore } from "../../../shared/stores/managed-service-state.store.js";
+import { spawn } from "node:child_process";
+import { getConfigPath, loadConfig } from "@nextclaw/core";
+//#region src/commands/remote/services/remote-service-control.service.ts
+const FORCED_PUBLIC_UI_HOST = "0.0.0.0";
+function resolveRemoteServiceView(currentUi) {
+	if (currentUi) return {
+		running: true,
+		currentProcess: true,
+		pid: process.pid,
+		uiUrl: resolveUiApiBase(currentUi.host, currentUi.port),
+		uiPort: currentUi.port
+	};
+	const serviceState = managedServiceStateStore.read();
+	const serviceRunning = Boolean(serviceState && isProcessRunning(serviceState.pid));
+	return {
+		running: serviceRunning,
+		currentProcess: Boolean(serviceRunning && serviceState?.pid === process.pid),
+		...serviceState?.pid ? { pid: serviceState.pid } : {},
+		...serviceState?.uiUrl ? { uiUrl: serviceState.uiUrl } : {},
+		...typeof serviceState?.uiPort === "number" ? { uiPort: serviceState.uiPort } : {}
+	};
+}
+async function controlRemoteService(action, deps) {
+	if (deps.remoteRuntimeController) return controlCurrentProcessRuntime(action, deps.remoteRuntimeController);
+	return controlManagedService(action, deps);
+}
+async function controlCurrentProcessRuntime(action, controller) {
+	if (action === "start") {
+		await controller.start();
+		return {
+			accepted: true,
+			action,
+			message: "Remote runtime started."
+		};
+	}
+	if (action === "stop") {
+		await controller.stop();
+		return {
+			accepted: true,
+			action,
+			message: "Remote runtime stopped."
+		};
+	}
+	await controller.restart();
+	return {
+		accepted: true,
+		action,
+		message: "Remote runtime restarted."
+	};
+}
+async function controlManagedService(action, deps) {
+	const state = managedServiceStateStore.read();
+	const running = Boolean(state && isProcessRunning(state.pid));
+	const currentProcess = Boolean(running && state?.pid === process.pid);
+	const uiOverrides = resolveManagedUiOverrides();
+	if (action === "start") {
+		if (running) return {
+			accepted: true,
+			action,
+			message: currentProcess ? "Managed service is already running for this UI." : "Managed service is already running."
+		};
+		await deps.serviceCommands.startService({
+			uiOverrides,
+			open: false
+		});
+		return {
+			accepted: true,
+			action,
+			message: "Managed service started."
+		};
+	}
+	if (!running) {
+		if (action === "restart") {
+			await deps.serviceCommands.startService({
+				uiOverrides,
+				open: false
+			});
+			return {
+				accepted: true,
+				action,
+				message: "Managed service was not running and has been started."
+			};
+		}
+		return {
+			accepted: true,
+			action,
+			message: "No managed service is currently running."
+		};
+	}
+	if (currentProcess) {
+		if (action === "restart") await deps.requestManagedServiceRestart({ uiPort: uiOverrides.port ?? 55667 });
+		else scheduleManagedSelfStop();
+		return {
+			accepted: true,
+			action,
+			message: action === "restart" ? "Restart scheduled. This page may disconnect for a few seconds." : "Stop scheduled. This page will disconnect shortly."
+		};
+	}
+	if (action === "stop") {
+		await deps.serviceCommands.stopService();
+		return {
+			accepted: true,
+			action,
+			message: "Managed service stopped."
+		};
+	}
+	await deps.serviceCommands.stopService();
+	await deps.serviceCommands.startService({
+		uiOverrides,
+		open: false
+	});
+	return {
+		accepted: true,
+		action,
+		message: "Managed service restarted."
+	};
+}
+function resolveManagedUiOverrides() {
+	return {
+		enabled: true,
+		host: FORCED_PUBLIC_UI_HOST,
+		open: false,
+		port: resolveUiConfig(loadConfig(getConfigPath()), {
+			enabled: true,
+			host: FORCED_PUBLIC_UI_HOST,
+			open: false
+		}).port
+	};
+}
+function scheduleManagedSelfStop() {
+	launchManagedSelfControl();
+}
+function launchManagedSelfControl(params = {}) {
+	const script = [
+		"const { spawn } = require(\"node:child_process\");",
+		"const { rmSync } = require(\"node:fs\");",
+		`const parentPid = ${process.pid};`,
+		`const serviceStatePath = ${JSON.stringify(managedServiceStateStore.path)};`,
+		`const command = ${JSON.stringify(params.command ?? null)};`,
+		`const args = ${JSON.stringify(params.args ?? [])};`,
+		`const cwd = ${JSON.stringify(process.cwd())};`,
+		"const env = process.env;",
+		"function isRunning(pid) {",
+		"  try {",
+		"    process.kill(pid, 0);",
+		"    return true;",
+		"  } catch {",
+		"    return false;",
+		"  }",
+		"}",
+		"setTimeout(() => {",
+		"  try {",
+		"    process.kill(parentPid, 'SIGTERM');",
+		"  } catch {}",
+		"}, 150);",
+		"const startedAt = Date.now();",
+		"const maxWaitMs = 30000;",
+		"const timer = setInterval(() => {",
+		"  if (isRunning(parentPid)) {",
+		"    if (Date.now() - startedAt > maxWaitMs) {",
+		"      try {",
+		"        process.kill(parentPid, 'SIGKILL');",
+		"      } catch {}",
+		"    }",
+		"    return;",
+		"  }",
+		"  clearInterval(timer);",
+		"  try {",
+		"    rmSync(serviceStatePath, { force: true });",
+		"  } catch {}",
+		"  if (command) {",
+		"    const child = spawn(command, args, { detached: true, stdio: 'ignore', cwd, env });",
+		"    child.unref();",
+		"  }",
+		"  process.exit(0);",
+		"}, 250);"
+	].join("");
+	spawn(process.execPath, ["-e", script], {
+		detached: true,
+		stdio: "ignore",
+		env: process.env,
+		cwd: process.cwd()
+	}).unref();
+}
+//#endregion
+export { controlRemoteService, resolveRemoteServiceView };

package/dist/commands/remote/utils/platform-api-base.utils.d.ts

@@ -0,0 +1,14 @@
+//#region src/commands/remote/utils/platform-api-base.utils.d.ts
+declare function resolvePlatformApiBase(params: {
+  explicitApiBase?: string | null;
+  configuredApiBase?: string | null;
+  fallbackApiBase?: string;
+  requireConfigured?: boolean;
+}): {
+  platformBase: string;
+  v1Base: string;
+  inputApiBase: string;
+};
+declare function buildPlatformApiBaseErrorMessage(inputApiBase: string, rawMessage: string): string;
+//#endregion
+export { buildPlatformApiBaseErrorMessage, resolvePlatformApiBase };

package/dist/commands/remote/utils/platform-api-base.utils.js

@@ -0,0 +1,39 @@
+//#region src/commands/remote/utils/platform-api-base.utils.ts
+const DEFAULT_PLATFORM_API_BASE = "https://ai-gateway-api.nextclaw.io/v1";
+const INVALID_PLATFORM_HINT = `Use ${DEFAULT_PLATFORM_API_BASE} or the platform root URL without a trailing path.`;
+function trimTrailingSlash(value) {
+	return value.replace(/\/+$/, "");
+}
+function normalizeExplicitApiBase(rawApiBase) {
+	const trimmed = trimTrailingSlash(rawApiBase.trim());
+	if (!trimmed) return "";
+	return trimmed.replace(/\/v1?$/i, "");
+}
+function resolvePlatformApiBase(params) {
+	const explicitApiBase = typeof params.explicitApiBase === "string" ? params.explicitApiBase.trim() : "";
+	const configuredApiBase = typeof params.configuredApiBase === "string" ? params.configuredApiBase.trim() : "";
+	const fallbackApiBase = params.fallbackApiBase ?? DEFAULT_PLATFORM_API_BASE;
+	const inputApiBase = explicitApiBase || configuredApiBase || (params.requireConfigured ? "" : fallbackApiBase);
+	if (!inputApiBase) throw new Error("Platform API base is missing. Pass --api-base or run nextclaw login.");
+	const platformBase = normalizeExplicitApiBase(inputApiBase);
+	if (!platformBase) throw new Error(`Invalid --api-base "${inputApiBase}". ${INVALID_PLATFORM_HINT}`);
+	let parsedUrl;
+	try {
+		parsedUrl = new URL(platformBase);
+	} catch {
+		throw new Error(`Invalid --api-base "${inputApiBase}". ${INVALID_PLATFORM_HINT}`);
+	}
+	if (parsedUrl.pathname !== "" && parsedUrl.pathname !== "/") throw new Error(`Invalid --api-base "${inputApiBase}". ${INVALID_PLATFORM_HINT}`);
+	const normalizedPlatformBase = trimTrailingSlash(parsedUrl.toString());
+	return {
+		platformBase: normalizedPlatformBase,
+		v1Base: `${normalizedPlatformBase}/v1`,
+		inputApiBase
+	};
+}
+function buildPlatformApiBaseErrorMessage(inputApiBase, rawMessage) {
+	if (rawMessage.includes("Remote session cookie missing") || rawMessage.includes("endpoint not found") || rawMessage.includes("NOT_FOUND")) return `Invalid --api-base "${inputApiBase}". ${INVALID_PLATFORM_HINT}`;
+	return rawMessage;
+}
+//#endregion
+export { buildPlatformApiBaseErrorMessage, resolvePlatformApiBase };

package/dist/commands/service/index.d.ts

@@ -0,0 +1,16 @@
+import { ServiceAutostartCommandOptions } from "../../shared/types/cli.types.js";
+
+//#region src/commands/service/index.d.ts
+declare class ServiceCommands {
+  private readonly hostAutostartCommandService;
+  installSystemd: (options?: ServiceAutostartCommandOptions) => Promise<void>;
+  uninstallSystemd: (options?: ServiceAutostartCommandOptions) => Promise<void>;
+  installLaunchAgent: (options?: ServiceAutostartCommandOptions) => Promise<void>;
+  uninstallLaunchAgent: (options?: ServiceAutostartCommandOptions) => Promise<void>;
+  installWindowsTask: (options?: ServiceAutostartCommandOptions) => Promise<void>;
+  uninstallWindowsTask: (options?: ServiceAutostartCommandOptions) => Promise<void>;
+  autostartStatus: (options?: ServiceAutostartCommandOptions) => Promise<void>;
+  autostartDoctor: (options?: ServiceAutostartCommandOptions) => Promise<void>;
+}
+//#endregion
+export { ServiceCommands };

package/dist/commands/service/index.js

@@ -0,0 +1,31 @@
+import { HostAutostartCommandService } from "./services/autostart/host-autostart-command.service.js";
+//#region src/commands/service/index.ts
+var ServiceCommands = class {
+	hostAutostartCommandService = new HostAutostartCommandService();
+	installSystemd = async (options = {}) => {
+		await this.hostAutostartCommandService.installSystemd(options);
+	};
+	uninstallSystemd = async (options = {}) => {
+		await this.hostAutostartCommandService.uninstallSystemd(options);
+	};
+	installLaunchAgent = async (options = {}) => {
+		await this.hostAutostartCommandService.installLaunchAgent(options);
+	};
+	uninstallLaunchAgent = async (options = {}) => {
+		await this.hostAutostartCommandService.uninstallLaunchAgent(options);
+	};
+	installWindowsTask = async (options = {}) => {
+		await this.hostAutostartCommandService.installWindowsTask(options);
+	};
+	uninstallWindowsTask = async (options = {}) => {
+		await this.hostAutostartCommandService.uninstallWindowsTask(options);
+	};
+	autostartStatus = async (options = {}) => {
+		await this.hostAutostartCommandService.autostartStatus(options);
+	};
+	autostartDoctor = async (options = {}) => {
+		await this.hostAutostartCommandService.autostartDoctor(options);
+	};
+};
+//#endregion
+export { ServiceCommands };

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

@@ -0,0 +1,29 @@
+import { ServiceAutostartCommandOptions } from "../../../../shared/types/cli.types.js";
+import { HostAutostartService } from "./host-autostart.service.js";
+
+//#region src/commands/service/services/autostart/host-autostart-command.service.d.ts
+type HostAutostartCommandServiceOptions = {
+  hostAutostartService?: HostAutostartService;
+};
+declare class HostAutostartCommandService {
+  private readonly hostAutostartService;
+  constructor(options?: HostAutostartCommandServiceOptions);
+  installSystemd: (options?: ServiceAutostartCommandOptions) => Promise<void>;
+  uninstallSystemd: (options?: ServiceAutostartCommandOptions) => Promise<void>;
+  installLaunchAgent: (options?: ServiceAutostartCommandOptions) => Promise<void>;
+  uninstallLaunchAgent: (options?: ServiceAutostartCommandOptions) => Promise<void>;
+  installWindowsTask: (options?: ServiceAutostartCommandOptions) => Promise<void>;
+  uninstallWindowsTask: (options?: ServiceAutostartCommandOptions) => Promise<void>;
+  autostartStatus: (options?: ServiceAutostartCommandOptions) => Promise<void>;
+  autostartDoctor: (options?: ServiceAutostartCommandOptions) => Promise<void>;
+  private handleInstallResult;
+  private handleUninstallResult;
+  private printInstallLikeResult;
+  private resolveRequiredSystemdScope;
+  private resolveOptionalSystemdScope;
+  private printAutostartStatus;
+  private printAutostartDoctor;
+  private formatOwner;
+}
+//#endregion
+export { HostAutostartCommandService };

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

@@ -0,0 +1,158 @@
+import { HostAutostartService } from "./host-autostart.service.js";
+//#region src/commands/service/services/autostart/host-autostart-command.service.ts
+var HostAutostartCommandService = class {
+	hostAutostartService;
+	constructor(options = {}) {
+		this.hostAutostartService = options.hostAutostartService ?? new HostAutostartService();
+	}
+	installSystemd = async (options = {}) => {
+		const scope = this.resolveRequiredSystemdScope(options);
+		if (!scope) {
+			process.exitCode = 1;
+			return;
+		}
+		const result = await this.hostAutostartService.installSystemd(scope, { dryRun: Boolean(options.dryRun) });
+		this.handleInstallResult(result, options, "systemd autostart installed.");
+	};
+	uninstallSystemd = async (options = {}) => {
+		const scope = this.resolveRequiredSystemdScope(options);
+		if (!scope) {
+			process.exitCode = 1;
+			return;
+		}
+		const result = await this.hostAutostartService.uninstallSystemd(scope, { dryRun: Boolean(options.dryRun) });
+		this.handleUninstallResult(result, options, "systemd autostart uninstalled.");
+	};
+	installLaunchAgent = async (options = {}) => {
+		const result = await this.hostAutostartService.installLaunchAgent({ dryRun: Boolean(options.dryRun) });
+		this.handleInstallResult(result, options, "LaunchAgent autostart installed.");
+	};
+	uninstallLaunchAgent = async (options = {}) => {
+		const result = await this.hostAutostartService.uninstallLaunchAgent({ dryRun: Boolean(options.dryRun) });
+		this.handleUninstallResult(result, options, "LaunchAgent autostart uninstalled.");
+	};
+	installWindowsTask = async (options = {}) => {
+		const result = await this.hostAutostartService.installWindowsTask({ dryRun: Boolean(options.dryRun) });
+		this.handleInstallResult(result, options, "Windows task autostart installed.");
+	};
+	uninstallWindowsTask = async (options = {}) => {
+		const result = await this.hostAutostartService.uninstallWindowsTask({ dryRun: Boolean(options.dryRun) });
+		this.handleUninstallResult(result, options, "Windows task autostart uninstalled.");
+	};
+	autostartStatus = async (options = {}) => {
+		const scope = this.resolveOptionalSystemdScope(options);
+		if (scope === "invalid") {
+			process.exitCode = 1;
+			return;
+		}
+		const status = await this.hostAutostartService.status(scope ?? void 0);
+		if (options.json) {
+			console.log(JSON.stringify(status, null, 2));
+			process.exitCode = 0;
+			return;
+		}
+		this.printAutostartStatus(status);
+		process.exitCode = 0;
+	};
+	autostartDoctor = async (options = {}) => {
+		const scope = this.resolveOptionalSystemdScope(options);
+		if (scope === "invalid") {
+			process.exitCode = 1;
+			return;
+		}
+		const report = await this.hostAutostartService.doctor(scope ?? void 0);
+		if (options.json) {
+			console.log(JSON.stringify(report, null, 2));
+			process.exitCode = report.exitCode;
+			return;
+		}
+		this.printAutostartDoctor(report);
+		process.exitCode = report.exitCode;
+	};
+	handleInstallResult = (result, options, successMessage) => {
+		if (options.json) {
+			console.log(JSON.stringify(result, null, 2));
+			process.exitCode = result.ok ? 0 : 1;
+			return;
+		}
+		if (!result.ok) {
+			process.exitCode = 1;
+			console.error(`Error: ${result.reasonIfUnavailable ?? "host autostart install failed."}`);
+			return;
+		}
+		this.printInstallLikeResult(result);
+		console.log(result.dryRun ? "Dry run complete." : successMessage);
+		process.exitCode = 0;
+	};
+	handleUninstallResult = (result, options, successMessage) => {
+		if (options.json) {
+			console.log(JSON.stringify(result, null, 2));
+			process.exitCode = result.ok ? 0 : 1;
+			return;
+		}
+		if (!result.ok) {
+			process.exitCode = 1;
+			console.error(`Error: ${result.reasonIfUnavailable ?? "host autostart uninstall failed."}`);
+			return;
+		}
+		this.printInstallLikeResult(result);
+		if (!result.removed) console.log("No installed host autostart resource was found.");
+		console.log(result.dryRun ? "Dry run complete." : successMessage);
+		process.exitCode = 0;
+	};
+	printInstallLikeResult = (result) => {
+		if (result.hostOwner) console.log(`Host autostart owner: ${this.formatOwner(result.hostOwner)}`);
+		if (result.scope) console.log(`Scope: ${result.scope}`);
+		if (result.resourceName) console.log(`Resource: ${result.resourceName}`);
+		if (result.resourcePath) console.log(`Resource path: ${result.resourcePath}`);
+		if ("homeDir" in result && result.homeDir) console.log(`Home: ${result.homeDir}`);
+		if ("command" in result && result.command) console.log(`Command: ${result.command}`);
+		if (result.logHint) console.log(`Logs: ${result.logHint}`);
+		for (const action of result.actions) console.log(`- ${action}`);
+	};
+	resolveRequiredSystemdScope = (options) => {
+		if (Boolean(options.user) === Boolean(options.system)) {
+			console.error("Error: Choose exactly one scope: --user or --system.");
+			return null;
+		}
+		return options.system ? "system" : "user";
+	};
+	resolveOptionalSystemdScope = (options) => {
+		const { system, user } = options;
+		if (user && system) {
+			console.error("Error: Choose at most one scope: --user or --system.");
+			return "invalid";
+		}
+		if (system) return "system";
+		if (user) return "user";
+		return null;
+	};
+	printAutostartStatus = (status) => {
+		console.log("Host autostart status:");
+		console.log(`- Supported: ${status.supported ? "yes" : "no"}`);
+		console.log(`- Installed: ${status.installed ? "yes" : "no"}`);
+		if (status.scope) console.log(`- Scope: ${status.scope}`);
+		if (status.hostOwner) console.log(`- Owner: ${this.formatOwner(status.hostOwner)}`);
+		if (status.resourceName) console.log(`- Resource: ${status.resourceName}`);
+		if (status.resourcePath) console.log(`- Resource path: ${status.resourcePath}`);
+		if (status.homeDir) console.log(`- Home: ${status.homeDir}`);
+		if (status.command) console.log(`- Command: ${status.command}`);
+		if (status.enabled !== null) console.log(`- Enabled: ${status.enabled ? "yes" : "no"}`);
+		if (status.active !== null) console.log(`- Active: ${status.active ? "yes" : "no"}`);
+		if (status.logHint) console.log(`- Logs: ${status.logHint}`);
+		if (status.reasonIfUnavailable) console.log(`- Note: ${status.reasonIfUnavailable}`);
+	};
+	printAutostartDoctor = (report) => {
+		this.printAutostartStatus(report.status);
+		console.log("Autostart doctor:");
+		for (const check of report.checks) console.log(`- [${check.status}] ${check.name}: ${check.detail}`);
+	};
+	formatOwner = (owner) => {
+		if (owner === "systemd-user-service") return "systemd user service";
+		if (owner === "systemd-system-service") return "systemd system service";
+		if (owner === "launchd-launch-agent") return "launchd LaunchAgent";
+		return "Windows Scheduled Task";
+	};
+};
+//#endregion
+export { HostAutostartCommandService };

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

@@ -0,0 +1,23 @@
+//#region src/commands/service/services/autostart/host-autostart-runtime.service.d.ts
+type HostAutostartRuntimeServiceOptions = {
+  nodePath?: string;
+  argvEntry?: string;
+  importMetaUrl?: string;
+  getDataDir?: () => string;
+};
+type HostAutostartLaunchPlan = {
+  homeDir: string;
+  command: string;
+  args: string[];
+};
+declare class HostAutostartRuntimeService {
+  private readonly nodePath;
+  private readonly argvEntry;
+  private readonly importMetaUrl;
+  private readonly getResolvedDataDir;
+  constructor(options?: HostAutostartRuntimeServiceOptions);
+  resolveForegroundServeLaunch: () => HostAutostartLaunchPlan;
+  private resolveCliEntry;
+}
+//#endregion
+export { HostAutostartLaunchPlan, HostAutostartRuntimeService };