@nextclaw/service 0.1.1

package/dist/launcher/npm-runtime-update.manager.js

@@ -0,0 +1,179 @@
+import { resolveEffectiveNpmRuntimeVersion } from "./npm-runtime-bundle.service.js";
+import { getPackageVersion } from "../shared/utils/package/package-manifest.utils.js";
+import "../shared/utils/cli.utils.js";
+//#region src/launcher/npm-runtime-update.manager.ts
+var NpmRuntimeUpdateManager = class {
+	launcherVersion;
+	now;
+	availableManifest = null;
+	constructor(options) {
+		this.options = options;
+		this.launcherVersion = options.launcherVersion ?? getPackageVersion();
+		this.now = options.now ?? (() => /* @__PURE__ */ new Date());
+		this.options.layout.ensureLauncherDirs();
+		this.syncStateFromCurrentPointer();
+	}
+	getSnapshot = () => this.toSnapshotFromState(this.options.stateStore.read(), { status: this.options.stateStore.read().downloadedVersion ? "downloaded" : "idle" });
+	run = async (options = {}) => {
+		if (options.apply) return this.applyDownloadedUpdate();
+		const checkedSnapshot = await this.checkForUpdate();
+		if (options.checkOnly || checkedSnapshot.status !== "update-available") return checkedSnapshot;
+		if (options.download === false) return checkedSnapshot;
+		return await this.downloadUpdate(options.onProgress);
+	};
+	checkForUpdate = async () => {
+		const manifestUrl = this.options.resolveManifestUrl(this.options.channel);
+		if (!this.options.updateService.hasSignatureVerifier()) return this.toSnapshotFromState(this.options.stateStore.read(), {
+			status: "blocked",
+			installationKind: "npm-runtime-bundle",
+			blockReason: "signature-verification-unavailable",
+			recoveryCommand: "Set NEXTCLAW_UPDATE_BUNDLE_PUBLIC_KEY or NEXTCLAW_UPDATE_BUNDLE_PUBLIC_KEY_PATH",
+			errorMessage: "Runtime bundle updates require a configured update public key."
+		});
+		if (!manifestUrl) return this.toSnapshotFromState(this.options.stateStore.read(), {
+			status: "blocked",
+			installationKind: "npm-runtime-bundle",
+			blockReason: "unsupported-installation",
+			recoveryCommand: "Set NEXTCLAW_UPDATE_MANIFEST_URL or NEXTCLAW_UPDATE_MANIFEST_BASE_URL",
+			errorMessage: "Runtime bundle update manifest URL is not configured."
+		});
+		const checkedAt = this.now().toISOString();
+		const state = this.options.stateStore.update((current) => ({
+			...current,
+			channel: this.options.channel,
+			lastUpdateCheckAt: checkedAt
+		}));
+		const availableUpdate = await this.options.updateService.checkForUpdate(manifestUrl, state.currentVersion, state.badVersions);
+		return this.toSnapshotAfterCheck(availableUpdate, this.options.stateStore.read());
+	};
+	downloadUpdate = async (onProgress) => {
+		const manifest = this.availableManifest ?? await this.ensureAvailableManifest();
+		const downloaded = await this.options.updateService.downloadAndInstallUpdate(manifest, onProgress);
+		const state = this.options.stateStore.update((current) => ({
+			...current,
+			downloadedVersion: downloaded.downloadedVersion,
+			downloadedReleaseNotesUrl: downloaded.manifest.releaseNotesUrl
+		}));
+		await this.options.bundleService.pruneRetainedArtifacts();
+		return this.toSnapshotFromState(state, {
+			status: "downloaded",
+			availableVersion: downloaded.downloadedVersion,
+			downloadedVersion: downloaded.downloadedVersion,
+			minimumHostVersion: downloaded.manifest.minimumLauncherVersion,
+			releaseNotesUrl: downloaded.manifest.releaseNotesUrl,
+			canApplyInApp: true,
+			requiresRestart: false
+		});
+	};
+	applyDownloadedUpdate = () => {
+		const downloadedVersion = this.options.stateStore.read().downloadedVersion?.trim();
+		if (!downloadedVersion) throw new Error("No downloaded npm runtime update is ready to apply.");
+		this.options.bundleService.activateVersion(downloadedVersion);
+		this.availableManifest = null;
+		return this.toSnapshotFromState(this.options.stateStore.read(), {
+			status: "restart-required",
+			availableVersion: null,
+			downloadedVersion: null,
+			releaseNotesUrl: null,
+			canApplyInApp: false,
+			requiresRestart: true
+		});
+	};
+	ensureAvailableManifest = async () => {
+		const snapshot = await this.checkForUpdate();
+		if (!this.availableManifest) {
+			if (snapshot.downloadedVersion) throw new Error(`Version ${snapshot.downloadedVersion} has already been downloaded and is ready to apply.`);
+			throw new Error("No npm runtime update is currently available.");
+		}
+		return this.availableManifest;
+	};
+	toSnapshotAfterCheck = (availableUpdate, state) => {
+		if (state.downloadedVersion) {
+			this.availableManifest = availableUpdate?.kind === "runtime-bundle-update" ? availableUpdate.manifest : this.availableManifest;
+			return this.toSnapshotFromState(state, {
+				status: "downloaded",
+				availableVersion: availableUpdate?.kind === "runtime-bundle-update" ? availableUpdate.manifest.latestVersion : state.downloadedVersion,
+				minimumHostVersion: availableUpdate?.kind === "runtime-bundle-update" ? availableUpdate.manifest.minimumLauncherVersion : null,
+				canApplyInApp: true,
+				requiresRestart: false
+			});
+		}
+		if (!availableUpdate) {
+			this.availableManifest = null;
+			return this.toSnapshotFromState(state, {
+				status: "up-to-date",
+				availableVersion: null,
+				downloadedVersion: null,
+				releaseNotesUrl: null
+			});
+		}
+		if (availableUpdate.kind === "host-update-required") {
+			this.availableManifest = null;
+			return this.toSnapshotFromState(state, {
+				status: "blocked",
+				availableVersion: availableUpdate.manifest.latestVersion,
+				minimumHostVersion: availableUpdate.manifest.minimumLauncherVersion,
+				releaseNotesUrl: availableUpdate.manifest.releaseNotesUrl,
+				blockReason: "host-too-old",
+				recoveryCommand: "npm install -g nextclaw@latest",
+				errorMessage: `NextClaw npm launcher ${this.launcherVersion} is too old for runtime bundle ${availableUpdate.manifest.latestVersion}.`
+			});
+		}
+		if (availableUpdate.kind === "quarantined-bad-version") {
+			this.availableManifest = null;
+			return this.toSnapshotFromState(state, {
+				status: "failed",
+				availableVersion: availableUpdate.manifest.latestVersion,
+				minimumHostVersion: availableUpdate.manifest.minimumLauncherVersion,
+				releaseNotesUrl: availableUpdate.manifest.releaseNotesUrl,
+				errorMessage: `Version ${availableUpdate.manifest.latestVersion} was quarantined after a failed launch.`
+			});
+		}
+		this.availableManifest = availableUpdate.manifest;
+		return this.toSnapshotFromState(state, {
+			status: "update-available",
+			availableVersion: availableUpdate.manifest.latestVersion,
+			minimumHostVersion: availableUpdate.manifest.minimumLauncherVersion,
+			releaseNotesUrl: availableUpdate.manifest.releaseNotesUrl
+		});
+	};
+	syncStateFromCurrentPointer = () => {
+		const currentPointer = this.options.layout.readCurrentPointer();
+		const effectiveCurrentVersion = resolveEffectiveNpmRuntimeVersion({
+			launcherVersion: this.launcherVersion,
+			currentBundleVersion: currentPointer?.version ?? null
+		});
+		if (!effectiveCurrentVersion) return;
+		this.options.stateStore.update((state) => ({
+			...state,
+			currentVersion: effectiveCurrentVersion
+		}));
+	};
+	toSnapshotFromState = (state, patch) => {
+		const hasDownloadedVersion = Boolean(state.downloadedVersion);
+		const { status } = patch;
+		return {
+			installationKind: "npm-runtime-bundle",
+			channel: state.channel,
+			hostVersion: this.launcherVersion,
+			currentVersion: state.currentVersion,
+			availableVersion: null,
+			downloadedVersion: state.downloadedVersion,
+			minimumHostVersion: null,
+			releaseNotesUrl: state.downloadedReleaseNotesUrl,
+			lastCheckedAt: state.lastUpdateCheckAt,
+			progress: null,
+			canAutoDownload: state.updatePreferences.autoDownload,
+			canApplyInApp: hasDownloadedVersion,
+			requiresRestart: false,
+			blockReason: null,
+			recoveryCommand: null,
+			errorMessage: null,
+			preferences: { ...state.updatePreferences },
+			...patch,
+			status
+		};
+	};
+};
+//#endregion
+export { NpmRuntimeUpdateManager };

package/dist/launcher/npm-runtime-update.service.d.ts

@@ -0,0 +1,54 @@
+import { NpmRuntimeDownloadedUpdate, NpmRuntimeUpdateProgressReporter } from "./npm-runtime-bundle.types.js";
+import { NpmRuntimeBundleLayoutStore } from "./npm-runtime-bundle-layout.store.js";
+import { NpmRuntimeBundleService } from "./npm-runtime-bundle.service.js";
+import { UpdateManifest, UpdateManifestReader } from "@nextclaw/kernel/update-contract";
+
+//#region src/launcher/npm-runtime-update.service.d.ts
+type FetchLike = typeof fetch;
+type NpmRuntimeUpdateServiceOptions = {
+  layout: NpmRuntimeBundleLayoutStore;
+  bundleService: NpmRuntimeBundleService;
+  launcherVersion: string;
+  bundlePublicKey?: string;
+  fetchImpl?: FetchLike;
+  platform?: NodeJS.Platform;
+  arch?: string;
+  manifestReader?: UpdateManifestReader;
+  now?: () => number;
+};
+type NpmRuntimeAvailableUpdate = {
+  kind: "runtime-bundle-update";
+  manifest: UpdateManifest;
+} | {
+  kind: "host-update-required";
+  manifest: UpdateManifest;
+} | {
+  kind: "quarantined-bad-version";
+  manifest: UpdateManifest;
+};
+declare class NpmRuntimeUpdateService {
+  private readonly options;
+  private readonly platform;
+  private readonly arch;
+  private readonly fetchImpl;
+  private readonly manifestReader;
+  private readonly bundlePublicKey;
+  private readonly now;
+  constructor(options: NpmRuntimeUpdateServiceOptions);
+  hasSignatureVerifier: () => boolean;
+  checkForUpdate: (manifestUrl: string, currentVersion: string | null, badVersions?: string[]) => Promise<NpmRuntimeAvailableUpdate | null>;
+  downloadAndInstallUpdate: (manifest: UpdateManifest, reportProgress?: NpmRuntimeUpdateProgressReporter) => Promise<NpmRuntimeDownloadedUpdate>;
+  private downloadBundleBytes;
+  private fetchManifest;
+  private verifyManifest;
+  private fetchBundle;
+  private readResponseBytes;
+  private readContentLength;
+  private reportDownloadProgress;
+  private findBundleRoot;
+  private parseBundlePublicKey;
+  private assertManifestSignature;
+  private assertBundleSignature;
+}
+//#endregion
+export { NpmRuntimeAvailableUpdate, NpmRuntimeUpdateService };

package/dist/launcher/npm-runtime-update.service.js

@@ -0,0 +1,183 @@
+import { compareNpmRuntimeVersions } from "./npm-runtime-bundle.service.js";
+import { fileURLToPath } from "node:url";
+import { dirname, join, resolve, sep } from "node:path";
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { rm } from "node:fs/promises";
+import { createHash, createPublicKey, verify } from "node:crypto";
+import JSZip from "jszip";
+import { UpdateManifestReader, serializeUnsignedUpdateManifest } from "@nextclaw/kernel/update-contract";
+//#region src/launcher/npm-runtime-update.service.ts
+var NpmRuntimeUpdateService = class {
+	platform;
+	arch;
+	fetchImpl;
+	manifestReader;
+	bundlePublicKey;
+	now;
+	constructor(options) {
+		this.options = options;
+		this.platform = options.platform ?? process.platform;
+		this.arch = options.arch ?? process.arch;
+		this.fetchImpl = options.fetchImpl ?? fetch;
+		this.manifestReader = options.manifestReader ?? new UpdateManifestReader();
+		this.bundlePublicKey = this.parseBundlePublicKey(options.bundlePublicKey);
+		this.now = options.now ?? Date.now;
+	}
+	hasSignatureVerifier = () => Boolean(this.bundlePublicKey);
+	checkForUpdate = async (manifestUrl, currentVersion, badVersions = []) => {
+		const manifest = await this.fetchManifest(manifestUrl);
+		if (currentVersion && compareNpmRuntimeVersions(manifest.latestVersion, currentVersion) <= 0) return null;
+		if (compareNpmRuntimeVersions(this.options.launcherVersion, manifest.minimumLauncherVersion) < 0) return {
+			kind: "host-update-required",
+			manifest
+		};
+		if (badVersions.includes(manifest.latestVersion)) return {
+			kind: "quarantined-bad-version",
+			manifest
+		};
+		return {
+			kind: "runtime-bundle-update",
+			manifest
+		};
+	};
+	downloadAndInstallUpdate = async (manifest, reportProgress) => {
+		const bytes = await this.downloadBundleBytes(manifest, reportProgress);
+		const stagingRoot = join(this.options.layout.getStagingDir(), `download-${manifest.latestVersion}-${this.now()}`);
+		await rm(stagingRoot, {
+			recursive: true,
+			force: true
+		});
+		mkdirSync(stagingRoot, { recursive: true });
+		try {
+			const zip = await JSZip.loadAsync(bytes);
+			const entries = Object.values(zip.files);
+			await Promise.all(entries.map(async (entry) => {
+				const targetPath = resolve(stagingRoot, entry.name);
+				const resolvedStagingRoot = resolve(stagingRoot);
+				if (targetPath !== resolvedStagingRoot && !targetPath.startsWith(`${resolvedStagingRoot}${sep}`)) throw new Error(`runtime bundle archive contains invalid path: ${entry.name}`);
+				if (entry.dir) {
+					mkdirSync(targetPath, { recursive: true });
+					return;
+				}
+				mkdirSync(dirname(targetPath), { recursive: true });
+				writeFileSync(targetPath, Buffer.from(await entry.async("uint8array")));
+			}));
+			const bundleRoot = this.findBundleRoot(stagingRoot);
+			const installedBundle = await this.options.bundleService.installFromDirectory(bundleRoot);
+			return {
+				manifest,
+				downloadedVersion: installedBundle.manifest.bundleVersion,
+				bundleDirectory: installedBundle.bundleDirectory
+			};
+		} catch (error) {
+			await rm(stagingRoot, {
+				recursive: true,
+				force: true
+			});
+			throw error;
+		}
+	};
+	downloadBundleBytes = async (manifest, reportProgress) => {
+		const response = await this.fetchBundle(manifest.bundleUrl);
+		const bytes = await this.readResponseBytes(response, reportProgress);
+		const sha256 = createHash("sha256").update(bytes).digest("hex");
+		if (sha256 !== manifest.bundleSha256) throw new Error(`runtime bundle sha256 mismatch: expected ${manifest.bundleSha256} but got ${sha256}`);
+		this.assertBundleSignature(manifest, bytes);
+		return bytes;
+	};
+	fetchManifest = async (manifestUrl) => {
+		if (manifestUrl.startsWith("file://")) {
+			const manifest = this.manifestReader.parse(JSON.parse(readFileSync(fileURLToPath(manifestUrl), "utf8")), manifestUrl);
+			return this.verifyManifest(manifest, manifestUrl);
+		}
+		const response = await this.fetchImpl(manifestUrl);
+		if (!response.ok) throw new Error(`runtime update manifest request failed with status ${response.status}`);
+		const manifest = this.manifestReader.parse(await response.json(), manifestUrl);
+		return this.verifyManifest(manifest, manifestUrl);
+	};
+	verifyManifest = (manifest, _manifestUrl) => {
+		if (manifest.hostKind && manifest.hostKind !== "npm-runtime-bundle") throw new Error(`runtime update manifest hostKind mismatch: expected npm-runtime-bundle but got ${manifest.hostKind}`);
+		if (manifest.channel !== "stable" && manifest.channel !== "beta") throw new Error(`runtime update manifest channel is unsupported: ${manifest.channel}`);
+		if (manifest.platform !== this.platform) throw new Error(`runtime update manifest platform mismatch: expected ${this.platform} but got ${manifest.platform}`);
+		if (manifest.arch !== this.arch) throw new Error(`runtime update manifest arch mismatch: expected ${this.arch} but got ${manifest.arch}`);
+		this.assertManifestSignature(manifest);
+		return manifest;
+	};
+	fetchBundle = async (bundleUrl) => {
+		if (bundleUrl.startsWith("file://")) {
+			const bytes = readFileSync(fileURLToPath(bundleUrl));
+			return new Response(bytes, {
+				status: 200,
+				headers: { "content-length": String(bytes.byteLength) }
+			});
+		}
+		const response = await this.fetchImpl(bundleUrl);
+		if (!response.ok) throw new Error(`runtime bundle download failed with status ${response.status}`);
+		return response;
+	};
+	readResponseBytes = async (response, reportProgress) => {
+		const totalBytes = this.readContentLength(response);
+		if (!response.body) {
+			const bytes = Buffer.from(await response.arrayBuffer());
+			this.reportDownloadProgress(reportProgress, bytes.byteLength, totalBytes ?? bytes.byteLength);
+			return bytes;
+		}
+		const reader = response.body.getReader();
+		const chunks = [];
+		let downloadedBytes = 0;
+		this.reportDownloadProgress(reportProgress, downloadedBytes, totalBytes);
+		while (true) {
+			const next = await reader.read();
+			if (next.done) break;
+			chunks.push(next.value);
+			downloadedBytes += next.value.byteLength;
+			this.reportDownloadProgress(reportProgress, downloadedBytes, totalBytes);
+		}
+		return Buffer.concat(chunks.map((chunk) => Buffer.from(chunk)));
+	};
+	readContentLength = (response) => {
+		const raw = response.headers.get("content-length");
+		if (!raw) return null;
+		const parsed = Number(raw);
+		return Number.isFinite(parsed) && parsed >= 0 ? parsed : null;
+	};
+	reportDownloadProgress = (reportProgress, downloadedBytes, totalBytes) => {
+		reportProgress?.({
+			downloadedBytes,
+			totalBytes,
+			percent: totalBytes && totalBytes > 0 ? Math.min(100, Math.round(downloadedBytes / totalBytes * 100)) : null
+		});
+	};
+	findBundleRoot = (stagingRoot) => {
+		if (existsSync(join(stagingRoot, "manifest.json"))) return stagingRoot;
+		const entries = readDirectoryNames(stagingRoot).filter((entry) => existsSync(join(stagingRoot, entry, "manifest.json")));
+		if (entries.length === 1) return join(stagingRoot, entries[0]);
+		throw new Error(`runtime bundle archive does not contain exactly one manifest root under ${stagingRoot}`);
+	};
+	parseBundlePublicKey = (publicKey) => {
+		const normalizedKey = publicKey?.trim();
+		if (!normalizedKey) return null;
+		const pemOrEscapedPem = normalizedKey.replaceAll("\\n", "\n");
+		if (pemOrEscapedPem.includes("BEGIN PUBLIC KEY")) return createPublicKey(pemOrEscapedPem);
+		return createPublicKey({
+			key: Buffer.from(normalizedKey, "base64"),
+			format: "der",
+			type: "spki"
+		});
+	};
+	assertManifestSignature = (manifest) => {
+		if (!this.bundlePublicKey) throw new Error("runtime update manifest signature verification requires bundlePublicKey");
+		const signature = Buffer.from(manifest.manifestSignature, "base64");
+		if (!verify(null, Buffer.from(serializeUnsignedUpdateManifest(manifest)), this.bundlePublicKey, signature)) throw new Error(`runtime update manifest signature verification failed for ${manifest.latestVersion}`);
+	};
+	assertBundleSignature = (manifest, bytes) => {
+		if (!this.bundlePublicKey) throw new Error("runtime bundle signature verification requires bundlePublicKey");
+		const signature = Buffer.from(manifest.bundleSignature, "base64");
+		if (!verify(null, bytes, this.bundlePublicKey, signature)) throw new Error(`runtime bundle signature verification failed for ${manifest.latestVersion}`);
+	};
+};
+function readDirectoryNames(directory) {
+	return readdirSync(directory, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+}
+//#endregion
+export { NpmRuntimeUpdateService };

package/dist/service-runtime.service.d.ts

@@ -0,0 +1,91 @@
+import { AgentCommandOptions, LoginCommandOptions, UpdateCommandOptions } from "./shared/types/cli.types.js";
+import { PluginCommands } from "./commands/plugin/index.js";
+import { AgentCommands } from "./cli/commands/agent/services/agent-commands.service.js";
+import { CompanionCommands } from "./cli/commands/companion/index.js";
+import { ConfigCommands } from "./cli/commands/config/services/config-commands.service.js";
+import { CronCommands } from "./cli/commands/cron/services/cron-commands.service.js";
+import { DiagnosticsCommands } from "./cli/commands/diagnostics/services/diagnostics-commands.service.js";
+import { GatewayCommands } from "./cli/commands/gateway/index.js";
+import { LogsCommands } from "./cli/commands/logs/index.js";
+import { McpCommands } from "./cli/commands/mcp/index.js";
+import { StartCommands } from "./cli/commands/start/index.js";
+import { RestartCommands } from "./cli/commands/restart/index.js";
+import { SecretsCommands } from "./cli/commands/secrets/index.js";
+import { ServeCommands } from "./cli/commands/serve/index.js";
+import { SkillsCommands } from "./cli/commands/skills/index.js";
+import { StopCommands } from "./cli/commands/stop/index.js";
+import { UiCommands } from "./cli/commands/ui/index.js";
+import { LlmUsageCommandService } from "./cli/commands/usage/services/llm-usage-command.service.js";
+import { ChannelCommands } from "./commands/channel/index.js";
+import { ServiceCommands } from "./commands/service/index.js";
+import { RemoteRuntimeActions } from "@nextclaw/remote";
+
+//#region src/service-runtime.service.d.ts
+type NextclawServiceRuntimeOptions = {
+  logo?: string;
+};
+type NextclawServiceRuntimeAccount = {
+  status: (opts?: {
+    apiBase?: string;
+    json?: boolean;
+  }) => Promise<void>;
+  setUsername: (username: string, opts?: {
+    apiBase?: string;
+    json?: boolean;
+  }) => Promise<void>;
+};
+type NextclawServiceCommands = {
+  remote: RemoteRuntimeActions;
+  skills: SkillsCommands;
+  service: ServiceCommands;
+  config: ConfigCommands;
+  mcp: McpCommands;
+  secrets: SecretsCommands;
+  plugins: PluginCommands;
+  agents: AgentCommands;
+  channels: ChannelCommands;
+  cron: CronCommands;
+  diagnostics: DiagnosticsCommands;
+  logs: LogsCommands;
+  gateway: GatewayCommands;
+  ui: UiCommands;
+  start: StartCommands;
+  restart: RestartCommands;
+  serve: ServeCommands;
+  stop: StopCommands;
+  companion: CompanionCommands;
+  usage: LlmUsageCommandService;
+};
+declare class NextclawServiceRuntime {
+  private logo;
+  private restartCoordinator;
+  private serviceRestartTask;
+  private selfRelaunchArmed;
+  private restartRequestService;
+  private workspaceManager;
+  private runtimeCommandService;
+  private platformAuthCommands;
+  private remoteCommands;
+  account: NextclawServiceRuntimeAccount;
+  commands: NextclawServiceCommands;
+  constructor(options?: NextclawServiceRuntimeOptions);
+  private createCommands;
+  get version(): string;
+  private scheduleProcessExit;
+  private restartBackgroundService;
+  private armManagedServiceRelaunch;
+  private requestRestart;
+  private writeRestartSentinelFromExecContext;
+  onboard: () => Promise<void>;
+  init: (options?: {
+    source?: string;
+    auto?: boolean;
+    force?: boolean;
+  }) => Promise<void>;
+  login: (opts?: LoginCommandOptions) => Promise<void>;
+  agent: (opts: AgentCommandOptions) => Promise<void>;
+  update: (opts: UpdateCommandOptions) => Promise<void>;
+}
+declare const runNextclawNpmRuntimeLauncher: (argv?: string[]) => void;
+//#endregion
+export { NextclawServiceCommands, NextclawServiceRuntime, NextclawServiceRuntimeAccount, NextclawServiceRuntimeOptions, runNextclawNpmRuntimeLauncher };