@nextclaw/service 0.1.1

package/dist/commands/plugin/plugin-mutation-actions.js

@@ -0,0 +1,162 @@
+import { buildReservedPluginLoadOptions } from "./plugin-command-utils.js";
+import { resolve } from "node:path";
+import { expandHome, getWorkspacePath, loadConfig, saveConfig } from "@nextclaw/core";
+import { existsSync } from "node:fs";
+import { addPluginLoadPath, buildPluginStatusReport, disablePluginInConfig, enablePluginInConfig, installPluginFromNpmSpec, installPluginFromPath, recordPluginInstall, uninstallPlugin } from "@nextclaw/openclaw-compat";
+//#region src/commands/plugin/plugin-mutation-actions.ts
+const pluginInstallLogger = {
+	info: (message) => console.log(message),
+	warn: (message) => console.warn(message)
+};
+function resolveFileNpmSpecToLocalPath(raw) {
+	const trimmed = raw.trim();
+	if (!trimmed.toLowerCase().startsWith("file:")) return null;
+	const rest = trimmed.slice(5);
+	if (!rest) return {
+		ok: false,
+		error: "unsupported file: spec: missing path"
+	};
+	if (rest.startsWith("///")) return {
+		ok: true,
+		path: rest.slice(2)
+	};
+	if (rest.startsWith("//localhost/")) return {
+		ok: true,
+		path: rest.slice(11)
+	};
+	if (rest.startsWith("//")) return {
+		ok: false,
+		error: "unsupported file: URL host (expected \"file:<path>\" or \"file:///abs/path\")"
+	};
+	return {
+		ok: true,
+		path: rest
+	};
+}
+function looksLikePath(raw) {
+	return raw.startsWith(".") || raw.startsWith("~") || raw.startsWith("/") || raw.endsWith(".ts") || raw.endsWith(".js") || raw.endsWith(".mjs") || raw.endsWith(".cjs") || raw.endsWith(".tgz") || raw.endsWith(".tar.gz") || raw.endsWith(".tar") || raw.endsWith(".zip");
+}
+function isArchivePath(filePath) {
+	const lower = filePath.toLowerCase();
+	return lower.endsWith(".zip") || lower.endsWith(".tgz") || lower.endsWith(".tar.gz") || lower.endsWith(".tar");
+}
+function saveLinkedPluginInstall(config, params) {
+	let next = addPluginLoadPath(config, params.resolvedPath);
+	next = enablePluginInConfig(next, params.pluginId);
+	next = recordPluginInstall(next, {
+		pluginId: params.pluginId,
+		source: "path",
+		sourcePath: params.resolvedPath,
+		installPath: params.resolvedPath,
+		version: params.version ?? void 0
+	});
+	saveConfig(next);
+	return { message: `Linked plugin path: ${params.resolvedPath}` };
+}
+function saveInstalledPluginResult(config, params) {
+	let next = enablePluginInConfig(config, params.pluginId);
+	next = recordPluginInstall(next, {
+		pluginId: params.pluginId,
+		source: params.source,
+		sourcePath: params.sourcePath,
+		spec: params.spec,
+		installPath: params.installPath,
+		version: params.version ?? void 0
+	});
+	saveConfig(next);
+	return { message: `Installed plugin: ${params.pluginId}` };
+}
+async function installPluginFromLocalPath(config, resolvedPath, link) {
+	if (link) {
+		const probe = await installPluginFromPath({
+			path: resolvedPath,
+			dryRun: true
+		});
+		if (!probe.ok) throw new Error(probe.error);
+		return saveLinkedPluginInstall(config, {
+			resolvedPath,
+			pluginId: probe.pluginId,
+			version: probe.version
+		});
+	}
+	const result = await installPluginFromPath({
+		path: resolvedPath,
+		logger: pluginInstallLogger
+	});
+	if (!result.ok) throw new Error(result.error);
+	return saveInstalledPluginResult(config, {
+		pluginId: result.pluginId,
+		source: isArchivePath(resolvedPath) ? "archive" : "path",
+		sourcePath: resolvedPath,
+		installPath: result.targetDir,
+		version: result.version
+	});
+}
+async function installPluginFromRegistrySpec(config, spec) {
+	const result = await installPluginFromNpmSpec({
+		spec,
+		logger: pluginInstallLogger
+	});
+	if (!result.ok) throw new Error(result.error);
+	return saveInstalledPluginResult(config, {
+		pluginId: result.pluginId,
+		source: "npm",
+		spec,
+		installPath: result.targetDir,
+		version: result.version
+	});
+}
+async function enablePluginMutation(id) {
+	saveConfig(enablePluginInConfig(loadConfig(), id));
+	return { message: `Enabled plugin "${id}".` };
+}
+async function disablePluginMutation(id) {
+	saveConfig(disablePluginInConfig(loadConfig(), id));
+	return { message: `Disabled plugin "${id}".` };
+}
+async function uninstallPluginMutation(id, opts = {}) {
+	const config = loadConfig();
+	const report = buildPluginStatusReport({
+		config,
+		workspaceDir: getWorkspacePath(config.agents.defaults.workspace),
+		...buildReservedPluginLoadOptions()
+	});
+	const keepFiles = Boolean(opts.keepFiles || opts.keepConfig);
+	const plugin = report.plugins.find((entry) => entry.id === id || entry.name === id);
+	const pluginId = plugin?.id ?? id;
+	const hasEntry = pluginId in (config.plugins.entries ?? {});
+	const hasInstall = pluginId in (config.plugins.installs ?? {});
+	if (!hasEntry && !hasInstall) {
+		if (plugin) throw new Error(`Plugin "${pluginId}" is not managed by plugins config/install records and cannot be uninstalled.`);
+		throw new Error(`Plugin not found: ${id}`);
+	}
+	const result = await uninstallPlugin({
+		config,
+		pluginId,
+		deleteFiles: !keepFiles
+	});
+	if (!result.ok) throw new Error(result.error);
+	saveConfig(result.config);
+	const removed = [];
+	if (result.actions.entry) removed.push("config entry");
+	if (result.actions.install) removed.push("install record");
+	if (result.actions.allowlist) removed.push("allowlist");
+	if (result.actions.loadPath) removed.push("load path");
+	if (result.actions.directory) removed.push("directory");
+	return {
+		message: `Uninstalled plugin "${pluginId}". Removed: ${removed.length > 0 ? removed.join(", ") : "nothing"}.`,
+		warnings: result.warnings
+	};
+}
+async function installPluginMutation(pathOrSpec, opts = {}) {
+	const fileSpec = resolveFileNpmSpecToLocalPath(pathOrSpec);
+	if (fileSpec && !fileSpec.ok) throw new Error(fileSpec.error);
+	const resolved = resolve(expandHome(fileSpec && fileSpec.ok ? fileSpec.path : pathOrSpec));
+	const config = loadConfig();
+	if (existsSync(resolved)) return installPluginFromLocalPath(config, resolved, Boolean(opts.link));
+	if (opts.link) throw new Error("`--link` requires a local path.");
+	if (looksLikePath(pathOrSpec)) throw new Error(`Path not found: ${resolved}`);
+	return installPluginFromRegistrySpec(config, pathOrSpec);
+}
+//#endregion
+export { disablePluginMutation, enablePluginMutation, installPluginMutation, uninstallPluginMutation };

package/dist/commands/plugin/plugin-registry-loader.d.ts

@@ -0,0 +1,15 @@
+import { Config } from "@nextclaw/core";
+import * as _$_nextclaw_openclaw_compat0 from "@nextclaw/openclaw-compat";
+import { PluginRegistry } from "@nextclaw/openclaw-compat";
+
+//#region src/commands/plugin/plugin-registry-loader.d.ts
+declare function loadPluginRegistryProgressively(config: Config, workspaceDir: string, options?: {
+  onPluginProcessed?: (params: {
+    loadedPluginCount: number;
+    pluginId?: string;
+  }) => void;
+}): Promise<PluginRegistry>;
+declare function discoverPluginRegistryStatus(config: Config, workspaceDir: string): _$_nextclaw_openclaw_compat0.PluginStatusReport;
+declare function createEmptyPluginRegistry(): PluginRegistry;
+//#endregion
+export { createEmptyPluginRegistry, discoverPluginRegistryStatus, loadPluginRegistryProgressively };

package/dist/commands/plugin/plugin-registry-loader.js

@@ -0,0 +1,43 @@
+import { buildReservedPluginLoadOptions } from "./plugin-command-utils.js";
+import { resolveDevFirstPartyPluginDir } from "./development-source/first-party-plugin-load-paths.js";
+import { resolveDevPluginLoadingContext } from "./development-source/dev-plugin-overrides.utils.js";
+import { getAppLogger } from "@nextclaw/core";
+import { discoverPluginStatusReport, loadOpenClawPluginsProgressively } from "@nextclaw/openclaw-compat";
+//#region src/commands/plugin/plugin-registry-loader.ts
+function createPluginLogger() {
+	return getAppLogger("plugin.registry_loader");
+}
+function withDevFirstPartyPluginPaths(config) {
+	return resolveDevPluginLoadingContext(config, resolveDevFirstPartyPluginDir(process.env.NEXTCLAW_DEV_FIRST_PARTY_PLUGIN_DIR));
+}
+async function loadPluginRegistryProgressively(config, workspaceDir, options = {}) {
+	const { configWithDevPluginOverrides, excludedRoots } = withDevFirstPartyPluginPaths(config);
+	return await loadOpenClawPluginsProgressively({
+		config: configWithDevPluginOverrides,
+		workspaceDir,
+		excludeRoots: excludedRoots,
+		...buildReservedPluginLoadOptions(),
+		onPluginProcessed: options.onPluginProcessed,
+		logger: createPluginLogger()
+	});
+}
+function discoverPluginRegistryStatus(config, workspaceDir) {
+	const { configWithDevPluginOverrides } = withDevFirstPartyPluginPaths(config);
+	return discoverPluginStatusReport({
+		config: configWithDevPluginOverrides,
+		workspaceDir
+	});
+}
+function createEmptyPluginRegistry() {
+	return {
+		plugins: [],
+		tools: [],
+		channels: [],
+		providers: [],
+		ncpAgentRuntimes: [],
+		diagnostics: [],
+		resolvedTools: []
+	};
+}
+//#endregion
+export { createEmptyPluginRegistry, discoverPluginRegistryStatus, loadPluginRegistryProgressively };

package/dist/commands/plugin/plugin-reload.d.ts

@@ -0,0 +1,13 @@
+import { ExtensionChannelRegistration } from "@nextclaw/core";
+import { PluginChannelBinding } from "@nextclaw/openclaw-compat";
+
+//#region src/commands/plugin/plugin-reload.d.ts
+declare function shouldRestartChannelsForPluginReload(params: {
+  changedPaths: readonly string[];
+  currentPluginChannelBindings: readonly PluginChannelBinding[];
+  nextPluginChannelBindings: readonly PluginChannelBinding[];
+  currentExtensionChannels: readonly ExtensionChannelRegistration[];
+  nextExtensionChannels: readonly ExtensionChannelRegistration[];
+}): boolean;
+//#endregion
+export { shouldRestartChannelsForPluginReload };

package/dist/commands/plugin/plugin-reload.js

@@ -0,0 +1,42 @@
+//#region src/commands/plugin/plugin-reload.ts
+function buildPluginChannelBindingSignature(binding) {
+	return `${binding.pluginId}:${binding.channelId}`;
+}
+function buildSortedBindingSignatures(bindings) {
+	return bindings.map(buildPluginChannelBindingSignature).sort();
+}
+function buildSortedExtensionChannelIds(channels) {
+	return channels.map((registration) => registration.channel.id).filter((id) => typeof id === "string" && id.trim().length > 0).sort();
+}
+function areSortedStringListsEqual(left, right) {
+	if (left.length !== right.length) return false;
+	for (let index = 0; index < left.length; index += 1) if (left[index] !== right[index]) return false;
+	return true;
+}
+function readPluginIdFromPluginsEntryPath(path) {
+	if (!path.startsWith("plugins.entries.")) return null;
+	const [pluginId] = path.slice(16).split(".");
+	return pluginId?.trim() ? pluginId.trim() : null;
+}
+function readChannelIdFromChannelPath(path) {
+	if (!path.startsWith("channels.")) return null;
+	const [channelId] = path.slice(9).split(".");
+	return channelId?.trim() ? channelId.trim() : null;
+}
+function shouldRestartChannelsForPluginReload(params) {
+	if (!areSortedStringListsEqual(buildSortedBindingSignatures(params.currentPluginChannelBindings), buildSortedBindingSignatures(params.nextPluginChannelBindings))) return true;
+	if (!areSortedStringListsEqual(buildSortedExtensionChannelIds(params.currentExtensionChannels), buildSortedExtensionChannelIds(params.nextExtensionChannels))) return true;
+	const channelPluginIds = /* @__PURE__ */ new Set();
+	for (const binding of params.currentPluginChannelBindings) channelPluginIds.add(binding.pluginId);
+	for (const binding of params.nextPluginChannelBindings) channelPluginIds.add(binding.pluginId);
+	for (const path of params.changedPaths) {
+		const pluginId = readPluginIdFromPluginsEntryPath(path);
+		if (pluginId && channelPluginIds.has(pluginId)) return true;
+		const channelId = readChannelIdFromChannelPath(path);
+		if (!channelId) continue;
+		if (params.currentPluginChannelBindings.some((binding) => binding.channelId === channelId) || params.nextPluginChannelBindings.some((binding) => binding.channelId === channelId)) return true;
+	}
+	return false;
+}
+//#endregion
+export { shouldRestartChannelsForPluginReload };

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

@@ -0,0 +1,47 @@
+import { buildNextclawConfiguredRemoteState, createNextclawRemoteConnector, createNextclawRemoteStatusStore, hasRunningNextclawManagedService, resolveNextclawRemoteStatusSnapshot } from "./services/remote-runtime-support.service.js";
+import { buildPlatformApiBaseErrorMessage, resolvePlatformApiBase } from "./utils/platform-api-base.utils.js";
+import { Config } from "@nextclaw/core";
+import { RemoteConnectCommandOptions, RemoteDoctorCommandOptions, RemoteEnableCommandOptions, RemoteStatusCommandOptions, RemoteStatusSnapshot } from "@nextclaw/remote";
+
+//#region src/commands/remote/index.d.ts
+type RemoteConfigChange = {
+  changed: boolean;
+  config: Config;
+};
+type RemoteCommandStatusView = {
+  configuredEnabled: boolean;
+  runtime: RemoteStatusSnapshot["runtime"];
+  localOrigin: string;
+  deviceName: string;
+  platformBase: string | null;
+};
+type RemoteCommandDoctorCheck = {
+  name: string;
+  ok: boolean;
+  detail: string;
+};
+type RemoteCommandDoctorView = {
+  generatedAt: string;
+  checks: RemoteCommandDoctorCheck[];
+  snapshot: RemoteStatusSnapshot;
+};
+declare class RemoteCommands {
+  private readonly deps;
+  constructor(deps?: {
+    currentLocalOrigin?: string;
+  });
+  updateConfig(params?: {
+    enabled?: boolean;
+    apiBase?: string;
+    name?: string;
+  }): RemoteConfigChange;
+  enableConfig(opts?: RemoteEnableCommandOptions): RemoteConfigChange;
+  disableConfig(): RemoteConfigChange;
+  connect(opts?: RemoteConnectCommandOptions): Promise<void>;
+  getStatusView(): RemoteCommandStatusView;
+  status(opts?: RemoteStatusCommandOptions): Promise<void>;
+  getDoctorView(): Promise<RemoteCommandDoctorView>;
+  doctor(opts?: RemoteDoctorCommandOptions): Promise<void>;
+}
+//#endregion
+export { RemoteCommandDoctorCheck, RemoteCommandDoctorView, RemoteCommandStatusView, RemoteCommands, buildNextclawConfiguredRemoteState, buildPlatformApiBaseErrorMessage, createNextclawRemoteConnector, createNextclawRemoteStatusStore, hasRunningNextclawManagedService, resolveNextclawRemoteStatusSnapshot, resolvePlatformApiBase };

package/dist/commands/remote/index.js

@@ -0,0 +1,174 @@
+import { localUiDiscoveryService } from "../../shared/services/ui/local-ui-discovery.service.js";
+import { buildPlatformApiBaseErrorMessage, resolvePlatformApiBase } from "./utils/platform-api-base.utils.js";
+import { buildNextclawConfiguredRemoteState, createNextclawRemoteConnector, createNextclawRemoteStatusStore, hasRunningNextclawManagedService, resolveNextclawRemoteStatusSnapshot } from "./services/remote-runtime-support.service.js";
+import { getConfigPath, loadConfig, saveConfig } from "@nextclaw/core";
+import { readPlatformSessionTokenState } from "@nextclaw/remote";
+import { hostname } from "node:os";
+//#region src/commands/remote/index.ts
+function normalizeOptionalString(value) {
+	if (typeof value !== "string") return;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : void 0;
+}
+function resolveConfiguredLocalOrigin(config) {
+	return localUiDiscoveryService.resolveLocalOrigin(config);
+}
+async function probeLocalUi(localOrigin) {
+	try {
+		const response = await fetch(`${localOrigin}/api/health`);
+		if (!response.ok) return {
+			ok: false,
+			detail: `health returned ${response.status}`
+		};
+		return {
+			ok: true,
+			detail: "health endpoint returned ok"
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			detail: error instanceof Error ? error.message : String(error)
+		};
+	}
+}
+function describePlatformTokenCheck(token) {
+	const tokenState = readPlatformSessionTokenState(token);
+	if (tokenState.valid) return {
+		name: "platform-token",
+		ok: true,
+		detail: "platform session token configured"
+	};
+	if (tokenState.reason === "expired") return {
+		name: "platform-token",
+		ok: false,
+		detail: "platform session token expired; run remote browser login or \"nextclaw login\" again"
+	};
+	if (tokenState.reason === "malformed") return {
+		name: "platform-token",
+		ok: false,
+		detail: "platform session token invalid; run remote browser login or \"nextclaw login\" again"
+	};
+	return {
+		name: "platform-token",
+		ok: false,
+		detail: "run remote browser login or \"nextclaw login\" first"
+	};
+}
+var RemoteCommands = class {
+	constructor(deps = {}) {
+		this.deps = deps;
+	}
+	updateConfig(params = {}) {
+		const config = loadConfig(getConfigPath());
+		const nextEnabled = typeof params.enabled === "boolean" ? params.enabled : config.remote.enabled;
+		const nextPlatformApiBase = typeof params.apiBase === "string" ? params.apiBase.trim() : config.remote.platformApiBase;
+		const nextDeviceName = typeof params.name === "string" ? params.name.trim() : config.remote.deviceName;
+		const next = {
+			...config,
+			remote: {
+				...config.remote,
+				enabled: nextEnabled,
+				platformApiBase: nextPlatformApiBase,
+				deviceName: nextDeviceName
+			}
+		};
+		saveConfig(next);
+		return {
+			changed: config.remote.enabled !== next.remote.enabled || config.remote.platformApiBase !== next.remote.platformApiBase || config.remote.deviceName !== next.remote.deviceName,
+			config: next
+		};
+	}
+	enableConfig(opts = {}) {
+		return this.updateConfig({
+			enabled: true,
+			apiBase: typeof opts.apiBase === "string" ? opts.apiBase : void 0,
+			name: typeof opts.name === "string" ? opts.name : void 0
+		});
+	}
+	disableConfig() {
+		return this.updateConfig({ enabled: false });
+	}
+	async connect(opts = {}) {
+		await createNextclawRemoteConnector().run({
+			...opts,
+			mode: "foreground"
+		});
+	}
+	getStatusView() {
+		const config = loadConfig(getConfigPath());
+		const snapshot = resolveNextclawRemoteStatusSnapshot(config);
+		const resolvedLocalOrigin = snapshot.runtime?.localOrigin ?? this.deps.currentLocalOrigin ?? resolveConfiguredLocalOrigin(config);
+		return {
+			configuredEnabled: snapshot.configuredEnabled,
+			runtime: snapshot.runtime,
+			localOrigin: resolvedLocalOrigin,
+			deviceName: snapshot.runtime?.deviceName ?? normalizeOptionalString(config.remote.deviceName) ?? hostname(),
+			platformBase: snapshot.runtime?.platformBase ?? normalizeOptionalString(config.remote.platformApiBase) ?? normalizeOptionalString(config.providers.nextclaw?.apiBase) ?? null
+		};
+	}
+	async status(opts = {}) {
+		const view = this.getStatusView();
+		if (opts.json) {
+			console.log(JSON.stringify(view, null, 2));
+			return;
+		}
+		const runtime = view.runtime;
+		console.log("NextClaw Remote Status");
+		console.log(`Enabled: ${view.configuredEnabled ? "yes" : "no"}`);
+		console.log(`Mode: ${runtime?.mode ?? "service"}`);
+		console.log(`State: ${runtime?.state ?? "disabled"}`);
+		console.log(`Device: ${view.deviceName}`);
+		console.log(`Platform: ${view.platformBase ?? "not set"}`);
+		console.log(`Local origin: ${runtime?.localOrigin ?? view.localOrigin}`);
+		if (runtime?.deviceId) console.log(`Device ID: ${runtime.deviceId}`);
+		if (runtime?.lastConnectedAt) console.log(`Last connected: ${runtime.lastConnectedAt}`);
+		if (runtime?.lastError) console.log(`Last error: ${runtime.lastError}`);
+	}
+	async getDoctorView() {
+		const config = loadConfig(getConfigPath());
+		const snapshot = resolveNextclawRemoteStatusSnapshot(config);
+		const localOrigin = snapshot.runtime?.localOrigin ?? this.deps.currentLocalOrigin ?? resolveConfiguredLocalOrigin(config);
+		const localUi = await probeLocalUi(localOrigin);
+		const token = normalizeOptionalString(config.providers.nextclaw?.apiKey);
+		const platformApiBase = normalizeOptionalString(config.remote.platformApiBase) ?? normalizeOptionalString(config.providers.nextclaw?.apiBase);
+		const checks = [
+			{
+				name: "remote-enabled",
+				ok: snapshot.configuredEnabled,
+				detail: snapshot.configuredEnabled ? "enabled in config" : "disabled in config"
+			},
+			describePlatformTokenCheck(token),
+			{
+				name: "platform-api-base",
+				ok: Boolean(platformApiBase),
+				detail: platformApiBase ?? "set remote.platformApiBase or login with --api-base"
+			},
+			{
+				name: "local-ui",
+				ok: localUi.ok,
+				detail: `${localOrigin} (${localUi.detail})`
+			},
+			{
+				name: "service-runtime",
+				ok: snapshot.runtime?.state === "connected",
+				detail: snapshot.runtime ? snapshot.runtime.state : "no managed remote runtime detected"
+			}
+		];
+		return {
+			generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			checks,
+			snapshot
+		};
+	}
+	async doctor(opts = {}) {
+		const report = await this.getDoctorView();
+		if (opts.json) {
+			console.log(JSON.stringify(report, null, 2));
+			return;
+		}
+		console.log("NextClaw Remote Doctor");
+		for (const check of report.checks) console.log(`${check.ok ? "✓" : "✗"} ${check.name}: ${check.detail}`);
+	}
+};
+//#endregion
+export { RemoteCommands, buildNextclawConfiguredRemoteState, buildPlatformApiBaseErrorMessage, createNextclawRemoteConnector, createNextclawRemoteStatusStore, hasRunningNextclawManagedService, resolveNextclawRemoteStatusSnapshot, resolvePlatformApiBase };

package/dist/commands/remote/services/remote-access-host.service.d.ts

@@ -0,0 +1,41 @@
+import { PlatformAuthCommands } from "../../platform-auth/services/platform-auth-commands.service.js";
+import { RemoteCommands } from "../index.js";
+import { RemoteAccessHostServiceCommands, RemoteRuntimeController } from "./remote-service-control.service.js";
+import { RemoteAccessView, RemoteBrowserAuthPollRequest, RemoteBrowserAuthPollResult, RemoteBrowserAuthStartRequest, RemoteBrowserAuthStartResult, RemoteDoctorView, RemoteServiceAction, RemoteServiceActionResult, RemoteSettingsUpdateRequest, UiRemoteAccessHost } from "@nextclaw/server";
+
+//#region src/commands/remote/services/remote-access-host.service.d.ts
+declare class RemoteAccessHost implements UiRemoteAccessHost {
+  private readonly deps;
+  constructor(deps: {
+    serviceCommands: RemoteAccessHostServiceCommands;
+    requestManagedServiceRestart: (options?: {
+      uiPort?: number;
+      reason?: string;
+    }) => Promise<void>;
+    remoteCommands: RemoteCommands;
+    platformAuthCommands: PlatformAuthCommands;
+    currentUi?: {
+      host: string;
+      port: number;
+    };
+    remoteRuntimeController?: RemoteRuntimeController | null;
+  });
+  getStatus: () => RemoteAccessView;
+  login: (input: {
+    email: string;
+    password: string;
+    apiBase?: string;
+  }) => Promise<RemoteAccessView>;
+  startBrowserAuth: (input: RemoteBrowserAuthStartRequest) => Promise<RemoteBrowserAuthStartResult>;
+  pollBrowserAuth: (input: RemoteBrowserAuthPollRequest) => Promise<RemoteBrowserAuthPollResult>;
+  logout: () => RemoteAccessView;
+  updateSettings: (input: RemoteSettingsUpdateRequest) => RemoteAccessView;
+  runDoctor: () => Promise<RemoteDoctorView>;
+  controlService: (action: RemoteServiceAction) => Promise<RemoteServiceActionResult>;
+  private readAccountView;
+  updateProfile: (input: {
+    username: string;
+  }) => Promise<RemoteAccessView>;
+}
+//#endregion
+export { RemoteAccessHost };

package/dist/commands/remote/services/remote-access-host.service.js

@@ -0,0 +1,126 @@
+import { controlRemoteService, resolveRemoteServiceView } from "./remote-service-control.service.js";
+import { getConfigPath, loadConfig } from "@nextclaw/core";
+import { readPlatformSessionTokenState } from "@nextclaw/remote";
+//#region src/commands/remote/services/remote-access-host.service.ts
+function normalizeOptionalString(value) {
+	if (typeof value !== "string") return null;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : null;
+}
+function toRemoteRuntimeView(runtime) {
+	if (!runtime) return null;
+	return {
+		enabled: runtime.enabled,
+		mode: runtime.mode,
+		state: runtime.state,
+		deviceId: runtime.deviceId,
+		deviceName: runtime.deviceName,
+		platformBase: runtime.platformBase,
+		localOrigin: runtime.localOrigin,
+		lastConnectedAt: runtime.lastConnectedAt,
+		lastError: runtime.lastError,
+		updatedAt: runtime.updatedAt
+	};
+}
+var RemoteAccessHost = class {
+	constructor(deps) {
+		this.deps = deps;
+	}
+	getStatus = () => {
+		const config = loadConfig(getConfigPath());
+		const status = this.deps.remoteCommands.getStatusView();
+		return {
+			account: this.readAccountView({
+				token: normalizeOptionalString(config.providers.nextclaw?.apiKey),
+				apiBase: normalizeOptionalString(config.providers.nextclaw?.apiBase),
+				platformBase: status.platformBase
+			}),
+			settings: {
+				enabled: config.remote.enabled,
+				deviceName: config.remote.deviceName,
+				platformApiBase: config.remote.platformApiBase
+			},
+			service: resolveRemoteServiceView(this.deps.currentUi),
+			localOrigin: status.localOrigin,
+			configuredEnabled: status.configuredEnabled,
+			platformBase: status.platformBase,
+			runtime: toRemoteRuntimeView(status.runtime)
+		};
+	};
+	login = async (input) => {
+		await this.deps.platformAuthCommands.loginResult(input);
+		return this.getStatus();
+	};
+	startBrowserAuth = async (input) => {
+		const result = await this.deps.platformAuthCommands.startBrowserAuth({ apiBase: input.apiBase });
+		return {
+			sessionId: result.sessionId,
+			verificationUri: result.verificationUri,
+			expiresAt: result.expiresAt,
+			intervalMs: result.intervalMs
+		};
+	};
+	pollBrowserAuth = async (input) => {
+		const config = loadConfig(getConfigPath());
+		const result = await this.deps.platformAuthCommands.pollBrowserAuth({
+			apiBase: normalizeOptionalString(input.apiBase) ?? normalizeOptionalString(config.remote.platformApiBase) ?? normalizeOptionalString(config.providers.nextclaw?.apiBase) ?? void 0,
+			sessionId: input.sessionId
+		});
+		if (result.status !== "authorized") return result;
+		return {
+			status: "authorized",
+			email: result.email,
+			role: result.role
+		};
+	};
+	logout = () => {
+		this.deps.platformAuthCommands.logout();
+		return this.getStatus();
+	};
+	updateSettings = (input) => {
+		this.deps.remoteCommands.updateConfig({
+			enabled: input.enabled,
+			apiBase: input.platformApiBase,
+			name: input.deviceName
+		});
+		return this.getStatus();
+	};
+	runDoctor = async () => {
+		const report = await this.deps.remoteCommands.getDoctorView();
+		return {
+			generatedAt: report.generatedAt,
+			checks: report.checks,
+			snapshot: {
+				configuredEnabled: report.snapshot.configuredEnabled,
+				runtime: toRemoteRuntimeView(report.snapshot.runtime)
+			}
+		};
+	};
+	controlService = async (action) => {
+		return controlRemoteService(action, this.deps);
+	};
+	readAccountView = (params) => {
+		const { apiBase, platformBase, token } = params;
+		const tokenState = readPlatformSessionTokenState(token);
+		if (!tokenState.valid) return {
+			loggedIn: false,
+			apiBase,
+			platformBase
+		};
+		const payload = tokenState.payload;
+		return {
+			loggedIn: true,
+			email: typeof payload?.email === "string" ? payload.email : void 0,
+			username: typeof payload?.username === "string" ? payload.username : void 0,
+			role: typeof payload?.role === "string" ? payload.role : void 0,
+			apiBase,
+			platformBase
+		};
+	};
+	updateProfile = async (input) => {
+		await this.deps.platformAuthCommands.updateProfile({ username: input.username });
+		return this.getStatus();
+	};
+};
+//#endregion
+export { RemoteAccessHost };