@nextclaw/service 0.1.1

package/dist/shared/services/session/service-deferred-ncp-agent.service.js

@@ -0,0 +1,85 @@
+//#region src/shared/services/session/service-deferred-ncp-agent.service.ts
+const DEFAULT_BASE_PATH = "/api/ncp/agent";
+const DEFERRED_NCP_AGENT_UNAVAILABLE = "ncp agent unavailable during startup";
+function createUnavailableError() {
+	return new Error(DEFERRED_NCP_AGENT_UNAVAILABLE);
+}
+var DeferredUiNcpAgentControllerOwner = class {
+	agent;
+	activeAgent = null;
+	endpoint = {
+		manifest: {
+			endpointKind: "agent",
+			endpointId: "nextclaw-ui-agent-deferred",
+			version: "0.0.0",
+			supportsStreaming: true,
+			supportsAbort: true,
+			supportsProactiveMessages: false,
+			supportsLiveSessionStream: true,
+			supportedPartTypes: ["text"],
+			expectedLatency: "seconds",
+			metadata: { deferred: true }
+		},
+		start: async () => {
+			await this.activeAgent?.agentClientEndpoint.start();
+		},
+		stop: async () => {
+			await this.activeAgent?.agentClientEndpoint.stop();
+		},
+		emit: async (event) => {
+			if (!this.activeAgent) throw createUnavailableError();
+			await this.activeAgent.agentClientEndpoint.emit(event);
+		},
+		subscribe: (listener) => {
+			if (!this.activeAgent) return () => void 0;
+			return this.activeAgent.agentClientEndpoint.subscribe(listener);
+		},
+		send: async (envelope) => {
+			if (!this.activeAgent) throw createUnavailableError();
+			await this.activeAgent.agentClientEndpoint.send(envelope);
+		},
+		stream: async (payload) => {
+			if (!this.activeAgent) throw createUnavailableError();
+			await this.activeAgent.agentClientEndpoint.stream(payload);
+		},
+		abort: async (payload) => {
+			if (!this.activeAgent) throw createUnavailableError();
+			await this.activeAgent.agentClientEndpoint.abort(payload);
+		}
+	};
+	constructor(basePath) {
+		this.basePath = basePath;
+		this.agent = {
+			basePath,
+			agentClientEndpoint: this.endpoint
+		};
+	}
+	activate = (nextAgent) => {
+		this.activeAgent = nextAgent;
+		this.agent.basePath = nextAgent.basePath ?? this.basePath;
+		this.agent.streamProvider = nextAgent.streamProvider;
+		this.agent.listSessionTypes = nextAgent.listSessionTypes;
+		this.agent.assetApi = nextAgent.assetApi;
+	};
+	clear = () => {
+		this.activeAgent = null;
+		this.agent.basePath = this.basePath;
+		this.agent.streamProvider = void 0;
+		this.agent.listSessionTypes = void 0;
+		this.agent.assetApi = void 0;
+	};
+	close = async () => {
+		const current = this.activeAgent;
+		this.clear();
+		await current?.agentClientEndpoint.stop();
+		await current?.dispose?.();
+	};
+	isReady = () => {
+		return this.activeAgent !== null;
+	};
+};
+function createDeferredUiNcpAgent(basePath = DEFAULT_BASE_PATH) {
+	return new DeferredUiNcpAgentControllerOwner(basePath);
+}
+//#endregion
+export { createDeferredUiNcpAgent };

package/dist/shared/services/ui/companion-runtime.service.d.ts

@@ -0,0 +1,33 @@
+import { LocalUiDiscoveryService } from "./local-ui-discovery.service.js";
+import { CompanionRuntimeState, CompanionRuntimeStore } from "../../stores/companion-runtime.store.js";
+import { Config } from "@nextclaw/core";
+
+//#region src/shared/services/ui/companion-runtime.service.d.ts
+declare class CompanionRuntimeService {
+  private readonly runtimeStore;
+  private readonly uiDiscoveryService;
+  constructor(runtimeStore?: CompanionRuntimeStore, uiDiscoveryService?: LocalUiDiscoveryService);
+  readonly getRunningState: () => CompanionRuntimeState | null;
+  readonly resolveDiscoveredBaseUrl: () => string | null;
+  readonly applyConfig: (config: Config) => Promise<void>;
+  readonly updateEnabled: (enabled: boolean, options?: {
+    baseUrl?: string;
+  }) => Promise<Config>;
+  readonly ensureStarted: (options: {
+    baseUrl: string;
+  }) => Promise<CompanionRuntimeState>;
+  readonly ensureStopped: (options?: {
+    force?: boolean;
+  }) => Promise<boolean>;
+  readonly printStatus: (options?: {
+    json?: boolean;
+  }) => void;
+  readonly printStarted: (state: CompanionRuntimeState) => void;
+  readonly printStopped: (stopped: boolean) => void;
+  private readonly killProcess;
+  private readonly resolveLaunchSpec;
+  private readonly waitForRunningState;
+}
+declare const companionRuntimeService: CompanionRuntimeService;
+//#endregion
+export { CompanionRuntimeService, companionRuntimeService };

package/dist/shared/services/ui/companion-runtime.service.js

@@ -0,0 +1,145 @@
+import { isProcessRunning } from "../../utils/cli.utils.js";
+import { companionRuntimeStore } from "../../stores/companion-runtime.store.js";
+import { localUiDiscoveryService } from "./local-ui-discovery.service.js";
+import { createRequire } from "node:module";
+import { spawn } from "node:child_process";
+import { dirname, resolve } from "node:path";
+import { APP_NAME, getConfigPath, loadConfig, saveConfig } from "@nextclaw/core";
+import { existsSync } from "node:fs";
+//#region src/shared/services/ui/companion-runtime.service.ts
+const require = createRequire(import.meta.url);
+var CompanionRuntimeService = class {
+	constructor(runtimeStore = companionRuntimeStore, uiDiscoveryService = localUiDiscoveryService) {
+		this.runtimeStore = runtimeStore;
+		this.uiDiscoveryService = uiDiscoveryService;
+	}
+	getRunningState = () => {
+		const state = this.runtimeStore.read();
+		if (!state) return null;
+		if (!isProcessRunning(state.pid)) {
+			this.runtimeStore.clear();
+			return null;
+		}
+		return state;
+	};
+	resolveDiscoveredBaseUrl = () => {
+		return this.uiDiscoveryService.resolveApiBase();
+	};
+	applyConfig = async (config) => {
+		if (!config.companion.enabled) {
+			await this.ensureStopped();
+			return;
+		}
+		await this.ensureStarted({ baseUrl: this.uiDiscoveryService.resolveLocalOrigin(config) });
+	};
+	updateEnabled = async (enabled, options = {}) => {
+		const config = loadConfig(getConfigPath());
+		const next = {
+			...config,
+			companion: {
+				...config.companion,
+				enabled
+			}
+		};
+		saveConfig(next, getConfigPath());
+		if (enabled) {
+			const explicitBaseUrl = options.baseUrl?.trim();
+			if (explicitBaseUrl) {
+				await this.ensureStarted({ baseUrl: explicitBaseUrl });
+				return next;
+			}
+			const discoveredBaseUrl = this.uiDiscoveryService.resolveApiBase();
+			if (discoveredBaseUrl) await this.ensureStarted({ baseUrl: discoveredBaseUrl });
+			return next;
+		}
+		await this.ensureStopped();
+		return next;
+	};
+	ensureStarted = async (options) => {
+		const baseUrl = options.baseUrl.trim().replace(/\/+$/, "");
+		const runningState = this.getRunningState();
+		if (runningState?.baseUrl === baseUrl) return runningState;
+		if (runningState) {
+			this.killProcess(runningState.pid, false);
+			this.runtimeStore.clear();
+		}
+		const launchSpec = this.resolveLaunchSpec();
+		const child = spawn(launchSpec.command, [
+			...launchSpec.args,
+			"--base-url",
+			baseUrl
+		], {
+			detached: true,
+			stdio: "ignore",
+			env: {
+				...process.env,
+				NEXTCLAW_COMPANION_RUNTIME_STATE_PATH: this.runtimeStore.path
+			}
+		});
+		child.unref();
+		return await this.waitForRunningState(baseUrl, child.pid ?? -1);
+	};
+	ensureStopped = async (options = {}) => {
+		const state = this.runtimeStore.read();
+		if (!state) return false;
+		if (!isProcessRunning(state.pid)) {
+			this.runtimeStore.clear();
+			return false;
+		}
+		this.killProcess(state.pid, options.force === true);
+		this.runtimeStore.clear();
+		return true;
+	};
+	printStatus = (options = {}) => {
+		const runningState = this.getRunningState();
+		const config = loadConfig(getConfigPath());
+		const view = runningState ? {
+			configuredEnabled: config.companion.enabled,
+			running: true,
+			...runningState
+		} : {
+			configuredEnabled: config.companion.enabled,
+			running: false
+		};
+		if (options.json) {
+			console.log(JSON.stringify(view, null, 2));
+			return;
+		}
+		if (!runningState) {
+			console.log(config.companion.enabled ? "Companion is enabled in config but is not running." : "Companion is disabled and not running.");
+			return;
+		}
+		console.log(`Companion is running (pid ${runningState.pid}) at ${runningState.baseUrl}. Configured enabled: ${config.companion.enabled ? "yes" : "no"}.`);
+	};
+	printStarted = (state) => {
+		console.log(`Started ${APP_NAME} companion (pid ${state.pid}) using ${state.baseUrl}.`);
+	};
+	printStopped = (stopped) => {
+		console.log(stopped ? "Stopped companion process." : "Companion is not running.");
+	};
+	killProcess = (pid, force) => {
+		process.kill(pid, force ? "SIGKILL" : "SIGTERM");
+	};
+	resolveLaunchSpec = () => {
+		const packageJsonPath = require.resolve("@nextclaw/companion/package.json");
+		const packageRoot = dirname(packageJsonPath);
+		const mainPath = resolve(packageRoot, "dist", "src", "main.js");
+		if (!existsSync(mainPath)) throw new Error(`Companion app build is missing at ${mainPath}. Build @nextclaw/companion first.`);
+		return {
+			command: createRequire(packageJsonPath)("electron"),
+			args: [packageRoot]
+		};
+	};
+	waitForRunningState = async (baseUrl, fallbackPid) => {
+		const timeoutAt = Date.now() + 5e3;
+		while (Date.now() < timeoutAt) {
+			const state = this.getRunningState();
+			if (state?.baseUrl === baseUrl) return state;
+			await new Promise((resolvePromise) => setTimeout(resolvePromise, 100));
+		}
+		throw new Error(fallbackPid > 0 ? `Companion started but did not report a live runtime state (launcher pid ${fallbackPid}).` : "Companion started but did not report a live runtime state.");
+	};
+};
+const companionRuntimeService = new CompanionRuntimeService();
+//#endregion
+export { CompanionRuntimeService, companionRuntimeService };

package/dist/shared/services/ui/local-ui-discovery.service.d.ts

@@ -0,0 +1,19 @@
+import { ManagedServiceState, ManagedServiceStateStore } from "../../stores/managed-service-state.store.js";
+import { LocalUiRuntimeState, LocalUiRuntimeStore } from "../../stores/local-ui-runtime.store.js";
+import { Config } from "@nextclaw/core";
+
+//#region src/shared/services/ui/local-ui-discovery.service.d.ts
+type DiscoveredLocalUiState = LocalUiRuntimeState | ManagedServiceState;
+declare class LocalUiDiscoveryService {
+  private readonly localUiStore;
+  private readonly managedServiceStore;
+  private readonly isProcessRunningFn;
+  constructor(localUiStore?: LocalUiRuntimeStore, managedServiceStore?: ManagedServiceStateStore, isProcessRunningFn?: (pid: number) => boolean);
+  private readonly readRunningState;
+  readonly readRunningRuntimeState: () => DiscoveredLocalUiState | null;
+  readonly resolveApiBase: () => string | null;
+  readonly resolveLocalOrigin: (config: Config) => string;
+}
+declare const localUiDiscoveryService: LocalUiDiscoveryService;
+//#endregion
+export { LocalUiDiscoveryService, localUiDiscoveryService };

package/dist/shared/services/ui/local-ui-discovery.service.js

@@ -0,0 +1,41 @@
+import { isProcessRunning } from "../../utils/cli.utils.js";
+import { localUiRuntimeStore } from "../../stores/local-ui-runtime.store.js";
+import { managedServiceStateStore } from "../../stores/managed-service-state.store.js";
+import { resolveLocalUiBaseUrl } from "@nextclaw/core";
+//#region src/shared/services/ui/local-ui-discovery.service.ts
+var LocalUiDiscoveryService = class {
+	constructor(localUiStore = localUiRuntimeStore, managedServiceStore = managedServiceStateStore, isProcessRunningFn = (pid) => isProcessRunning(pid)) {
+		this.localUiStore = localUiStore;
+		this.managedServiceStore = managedServiceStore;
+		this.isProcessRunningFn = isProcessRunningFn;
+	}
+	readRunningState = (state) => {
+		if (!state || !this.isProcessRunningFn(state.pid)) return null;
+		return state;
+	};
+	readRunningRuntimeState = () => {
+		return this.readRunningState(this.localUiStore.read()) ?? this.readRunningState(this.managedServiceStore.read());
+	};
+	resolveApiBase = () => {
+		const state = this.readRunningRuntimeState();
+		if (!state) return null;
+		if (typeof state.uiUrl === "string" && state.uiUrl.trim().length > 0) return state.uiUrl.replace(/\/+$/, "");
+		if (typeof state.apiUrl === "string" && state.apiUrl.trim().length > 0) return state.apiUrl.replace(/\/api\/?$/, "").replace(/\/+$/, "");
+		return null;
+	};
+	resolveLocalOrigin = (config) => {
+		const state = this.readRunningRuntimeState();
+		const runtimePort = state && typeof state.uiPort === "number" && Number.isFinite(state.uiPort) ? state.uiPort : null;
+		if (runtimePort !== null) return resolveLocalUiBaseUrl({
+			host: "0.0.0.0",
+			port: runtimePort
+		});
+		return resolveLocalUiBaseUrl({
+			host: "0.0.0.0",
+			port: typeof config.ui.port === "number" && Number.isFinite(config.ui.port) ? config.ui.port : 55667
+		});
+	};
+};
+const localUiDiscoveryService = new LocalUiDiscoveryService();
+//#endregion
+export { LocalUiDiscoveryService, localUiDiscoveryService };

package/dist/shared/services/ui/npm-runtime-update-host.service.d.ts

@@ -0,0 +1,40 @@
+import { RequestRestartParams } from "../../types/cli.types.js";
+import { Config } from "@nextclaw/core";
+import { UiRuntimeUpdateHost } from "@nextclaw/server";
+import { EventBus, UpdatePreferences, UpdateSnapshot } from "@nextclaw/shared";
+
+//#region src/shared/services/ui/npm-runtime-update-host.service.d.ts
+type NpmRuntimeUpdateHostDeps = {
+  eventBus: EventBus;
+  requestRestart: (params: RequestRestartParams) => Promise<void>;
+  uiConfig: Pick<Config["ui"], "port">;
+  applyRestartMode: "managed-service-restart" | "manual-process-restart";
+};
+declare class NpmRuntimeUpdateHost implements UiRuntimeUpdateHost {
+  private readonly deps;
+  private readonly source;
+  private readonly layout;
+  private readonly launcherVersion;
+  private readonly stateStore;
+  private readonly bundleService;
+  private readonly updateService;
+  private snapshot;
+  private activeTask;
+  private automaticSyncStarted;
+  constructor(deps: NpmRuntimeUpdateHostDeps);
+  getState: () => Promise<UpdateSnapshot>;
+  checkForUpdates: () => Promise<UpdateSnapshot>;
+  downloadUpdate: () => Promise<UpdateSnapshot>;
+  applyDownloadedUpdate: () => Promise<UpdateSnapshot>;
+  updatePreferences: (preferences: Partial<UpdatePreferences>) => Promise<UpdateSnapshot>;
+  updateChannel: (channel: UpdateSnapshot["channel"]) => Promise<UpdateSnapshot>;
+  private startAutomaticSync;
+  private startCheck;
+  private startDownload;
+  private runDownloadTask;
+  private createManager;
+  private toFailedSnapshot;
+  private setSnapshot;
+}
+//#endregion
+export { NpmRuntimeUpdateHost };

package/dist/shared/services/ui/npm-runtime-update-host.service.js

@@ -0,0 +1,181 @@
+import { NpmRuntimeBundleLayoutStore } from "../../../launcher/npm-runtime-bundle-layout.store.js";
+import { NpmRuntimeBundleService } from "../../../launcher/npm-runtime-bundle.service.js";
+import { NpmRuntimeUpdateSourceService } from "../../../launcher/npm-runtime-update-source.service.js";
+import { NpmRuntimeUpdateStateStore } from "../../../launcher/npm-runtime-update-state.store.js";
+import { getPackageVersion } from "../../utils/package/package-manifest.utils.js";
+import "../../utils/cli.utils.js";
+import { NpmRuntimeUpdateManager } from "../../../launcher/npm-runtime-update.manager.js";
+import { NpmRuntimeUpdateService } from "../../../launcher/npm-runtime-update.service.js";
+import { requestManagedServiceRestart } from "./service-remote-access.service.js";
+import { eventKeys } from "@nextclaw/shared";
+//#region src/shared/services/ui/npm-runtime-update-host.service.ts
+const INITIAL_DOWNLOAD_PROGRESS = {
+	downloadedBytes: 0,
+	totalBytes: null,
+	percent: null
+};
+var NpmRuntimeUpdateHost = class {
+	source = new NpmRuntimeUpdateSourceService();
+	layout = new NpmRuntimeBundleLayoutStore();
+	launcherVersion = getPackageVersion();
+	stateStore = new NpmRuntimeUpdateStateStore(this.layout.getStatePath(), { defaultChannel: this.source.resolveChannel(void 0, this.launcherVersion) });
+	bundleService = new NpmRuntimeBundleService({
+		layout: this.layout,
+		stateStore: this.stateStore,
+		launcherVersion: this.launcherVersion
+	});
+	updateService = new NpmRuntimeUpdateService({
+		layout: this.layout,
+		bundleService: this.bundleService,
+		launcherVersion: this.launcherVersion,
+		bundlePublicKey: this.source.resolveBundlePublicKey() ?? void 0
+	});
+	snapshot;
+	activeTask = null;
+	automaticSyncStarted = false;
+	constructor(deps) {
+		this.deps = deps;
+		this.snapshot = this.createManager().getSnapshot();
+		this.startAutomaticSync();
+	}
+	getState = async () => {
+		this.startAutomaticSync();
+		return this.snapshot;
+	};
+	checkForUpdates = async () => {
+		return this.startCheck({ autoDownload: false });
+	};
+	downloadUpdate = async () => {
+		return this.startDownload();
+	};
+	applyDownloadedUpdate = async () => {
+		if (this.activeTask) return this.snapshot;
+		this.setSnapshot({
+			...this.snapshot,
+			status: "applying",
+			progress: null,
+			errorMessage: null
+		});
+		try {
+			const snapshot = this.createManager().applyDownloadedUpdate();
+			this.setSnapshot(this.deps.applyRestartMode === "managed-service-restart" ? snapshot : {
+				...snapshot,
+				recoveryCommand: "Restart this NextClaw process to launch the downloaded runtime."
+			});
+			if (this.deps.applyRestartMode === "managed-service-restart") await requestManagedServiceRestart(this.deps.requestRestart, {
+				reason: "runtime update apply",
+				uiPort: this.deps.uiConfig.port
+			});
+			return this.snapshot;
+		} catch (error) {
+			this.setSnapshot(this.toFailedSnapshot(error));
+			throw error;
+		}
+	};
+	updatePreferences = async (preferences) => {
+		const nextState = this.stateStore.update((current) => ({
+			...current,
+			updatePreferences: {
+				...current.updatePreferences,
+				...preferences
+			}
+		}));
+		this.setSnapshot(this.createManager(nextState.channel).getSnapshot());
+		if (nextState.updatePreferences.automaticChecks) this.startAutomaticSync({ force: true });
+		return this.snapshot;
+	};
+	updateChannel = async (channel) => {
+		const nextState = this.stateStore.update((current) => ({
+			...current,
+			channel
+		}));
+		this.setSnapshot(this.createManager(nextState.channel).getSnapshot());
+		if (nextState.updatePreferences.automaticChecks) return this.startCheck({ autoDownload: nextState.updatePreferences.autoDownload });
+		return this.snapshot;
+	};
+	startAutomaticSync = (options = {}) => {
+		if (this.activeTask) return;
+		if (this.automaticSyncStarted && !options.force) return;
+		this.automaticSyncStarted = true;
+		const state = this.stateStore.read();
+		if (!state.updatePreferences.automaticChecks || state.downloadedVersion) return;
+		this.startCheck({ autoDownload: state.updatePreferences.autoDownload });
+	};
+	startCheck = async (options) => {
+		if (this.activeTask) return this.snapshot;
+		this.setSnapshot({
+			...this.createManager().getSnapshot(),
+			status: "checking",
+			progress: null,
+			errorMessage: null
+		});
+		this.activeTask = (async () => {
+			try {
+				const checkedSnapshot = await this.createManager().checkForUpdate();
+				this.setSnapshot(checkedSnapshot);
+				if (options.autoDownload && checkedSnapshot.status === "update-available") await this.runDownloadTask();
+			} catch (error) {
+				this.setSnapshot(this.toFailedSnapshot(error));
+			} finally {
+				this.activeTask = null;
+			}
+		})();
+		return this.snapshot;
+	};
+	startDownload = async () => {
+		if (this.activeTask) return this.snapshot;
+		this.setSnapshot({
+			...this.createManager().getSnapshot(),
+			status: "downloading",
+			progress: INITIAL_DOWNLOAD_PROGRESS,
+			errorMessage: null
+		});
+		this.activeTask = (async () => {
+			try {
+				await this.runDownloadTask();
+			} catch (error) {
+				this.setSnapshot(this.toFailedSnapshot(error));
+			} finally {
+				this.activeTask = null;
+			}
+		})();
+		return this.snapshot;
+	};
+	runDownloadTask = async () => {
+		const downloadedSnapshot = await this.createManager().downloadUpdate((progress) => {
+			this.setSnapshot({
+				...this.snapshot,
+				status: "downloading",
+				progress,
+				errorMessage: null
+			});
+		});
+		this.setSnapshot(downloadedSnapshot);
+	};
+	createManager = (channel = this.stateStore.read().channel) => {
+		return new NpmRuntimeUpdateManager({
+			layout: this.layout,
+			stateStore: this.stateStore,
+			bundleService: this.bundleService,
+			updateService: this.updateService,
+			resolveManifestUrl: (resolvedChannel) => this.source.resolveManifestUrl(resolvedChannel),
+			launcherVersion: this.launcherVersion,
+			channel
+		});
+	};
+	toFailedSnapshot = (error) => {
+		return {
+			...this.createManager().getSnapshot(),
+			status: "failed",
+			progress: null,
+			errorMessage: error instanceof Error ? error.message : String(error ?? "Unknown error")
+		};
+	};
+	setSnapshot = (snapshot) => {
+		this.snapshot = snapshot;
+		this.deps.eventBus.emit(eventKeys.runtimeUpdateSnapshot, snapshot, { source: "backend" });
+		return snapshot;
+	};
+};
+//#endregion
+export { NpmRuntimeUpdateHost };

package/dist/shared/services/ui/runtime-control-host.service.d.ts

@@ -0,0 +1,28 @@
+import { RequestRestartParams } from "../../types/cli.types.js";
+import { Config } from "@nextclaw/core";
+import { RuntimeControlActionResult, RuntimeControlView, UiRuntimeControlHost } from "@nextclaw/server";
+
+//#region src/shared/services/ui/runtime-control-host.service.d.ts
+type RuntimeControlHostDeps = {
+  serviceCommands: {
+    startService: (options: {
+      uiOverrides: Record<string, unknown>;
+      open: boolean;
+    }) => Promise<void>;
+    stopService: () => Promise<void>;
+  };
+  requestRestart: (params: RequestRestartParams) => Promise<void>;
+  uiConfig: Pick<Config["ui"], "host" | "port">;
+};
+declare class RuntimeControlHost implements UiRuntimeControlHost {
+  private readonly deps;
+  constructor(deps: RuntimeControlHostDeps);
+  getControl: () => RuntimeControlView;
+  startService: () => Promise<RuntimeControlActionResult>;
+  restartService: () => Promise<RuntimeControlActionResult>;
+  stopService: () => Promise<RuntimeControlActionResult>;
+  private createServiceControlDeps;
+}
+declare function createRuntimeControlHost(params: RuntimeControlHostDeps): RuntimeControlHost;
+//#endregion
+export { RuntimeControlHost, createRuntimeControlHost };

package/dist/shared/services/ui/runtime-control-host.service.js

@@ -0,0 +1,89 @@
+import { pendingRestartStore } from "../../stores/pending-restart.store.js";
+import { controlRemoteService, resolveRemoteServiceView } from "../../../commands/remote/services/remote-service-control.service.js";
+import { requestManagedServiceRestart } from "./service-remote-access.service.js";
+//#region src/shared/services/ui/runtime-control-host.service.ts
+const MANAGED_SERVICE_OWNER_LABEL = "Managed local service";
+const DESKTOP_APP_ONLY_REASON = "App restart is only available in the desktop shell.";
+const RUNNING_PAGE_START_REASON = "This page is already hosted by the running local service.";
+var RuntimeControlHost = class {
+	constructor(deps) {
+		this.deps = deps;
+	}
+	getControl = () => {
+		const service = resolveRemoteServiceView(this.deps.uiConfig);
+		const serviceRunning = service.running;
+		const pendingRestart = pendingRestartStore.read();
+		return {
+			environment: "managed-local-service",
+			lifecycle: serviceRunning ? "healthy" : "unavailable",
+			serviceState: serviceRunning ? "running" : "stopped",
+			canStartService: {
+				available: !serviceRunning,
+				requiresConfirmation: false,
+				impact: "brief-ui-disconnect",
+				...serviceRunning ? { reasonIfUnavailable: RUNNING_PAGE_START_REASON } : {}
+			},
+			canRestartService: {
+				available: serviceRunning,
+				requiresConfirmation: false,
+				impact: "brief-ui-disconnect",
+				...!serviceRunning ? { reasonIfUnavailable: "The local service is not running." } : {}
+			},
+			canStopService: {
+				available: serviceRunning,
+				requiresConfirmation: true,
+				impact: "brief-ui-disconnect",
+				...!serviceRunning ? { reasonIfUnavailable: "The local service is already stopped." } : {}
+			},
+			canRestartApp: {
+				available: false,
+				requiresConfirmation: true,
+				impact: "full-app-relaunch",
+				reasonIfUnavailable: DESKTOP_APP_ONLY_REASON
+			},
+			pendingRestart,
+			ownerLabel: MANAGED_SERVICE_OWNER_LABEL,
+			managementHint: service.currentProcess ? "This page is served by the running local service. Closing the browser does not stop it." : "Manage the local NextClaw service from this page without tying service lifecycle to the browser tab.",
+			message: "Use this page to manage the local NextClaw service. Closing the browser does not stop the service."
+		};
+	};
+	startService = async () => {
+		const result = await controlRemoteService("start", this.createServiceControlDeps());
+		return {
+			accepted: result.accepted,
+			action: "start-service",
+			lifecycle: "starting-service",
+			message: result.message
+		};
+	};
+	restartService = async () => {
+		const result = await controlRemoteService("restart", this.createServiceControlDeps());
+		return {
+			accepted: result.accepted,
+			action: "restart-service",
+			lifecycle: "restarting-service",
+			message: result.message
+		};
+	};
+	stopService = async () => {
+		const result = await controlRemoteService("stop", this.createServiceControlDeps());
+		return {
+			accepted: result.accepted,
+			action: "stop-service",
+			lifecycle: "stopping-service",
+			message: result.message
+		};
+	};
+	createServiceControlDeps = () => {
+		return {
+			serviceCommands: this.deps.serviceCommands,
+			requestManagedServiceRestart: () => requestManagedServiceRestart(this.deps.requestRestart, { uiPort: this.deps.uiConfig.port }),
+			currentUi: this.deps.uiConfig
+		};
+	};
+};
+function createRuntimeControlHost(params) {
+	return new RuntimeControlHost(params);
+}
+//#endregion
+export { RuntimeControlHost, createRuntimeControlHost };