@promptbook/cli 0.113.0-8 → 0.114.0-0

package/apps/agents-server/src/utils/vpsSelfUpdate/vpsSelfUpdateCron.ts

@@ -0,0 +1,357 @@
+import { NotAllowed } from '../../../../../src/errors/NotAllowed';
+import { spaceTrim } from 'spacetrim';
+
+/**
+ * Default automatic self-update cron expression: every day at midnight.
+ *
+ * @private constant of `vpsSelfUpdate`
+ */
+export const DEFAULT_VPS_SELF_UPDATE_CRON_EXPRESSION = '0 0 * * *';
+
+/**
+ * Number of fields in a standard minute-based cron expression.
+ *
+ * @private constant of `vpsSelfUpdate`
+ */
+const VPS_SELF_UPDATE_CRON_FIELD_COUNT = 5;
+
+/**
+ * Maximum number of minutes scanned while finding the next cron run.
+ *
+ * Five years keeps leap-day schedules valid while still rejecting impossible expressions.
+ *
+ * @private constant of `vpsSelfUpdate`
+ */
+const VPS_SELF_UPDATE_CRON_LOOKAHEAD_MINUTES = 366 * 24 * 60 * 5;
+
+/**
+ * Parsed cron field values.
+ *
+ * @private type of `vpsSelfUpdateCron`
+ */
+type VpsSelfUpdateCronField = {
+    /**
+     * Accepted numeric values for this field.
+     */
+    readonly values: ReadonlySet<number>;
+    /**
+     * Whether the field is the unrestricted `*` wildcard.
+     */
+    readonly isWildcard: boolean;
+};
+
+/**
+ * Parsed five-field cron expression.
+ *
+ * @private type of `vpsSelfUpdateCron`
+ */
+type VpsSelfUpdateCronExpression = {
+    readonly minute: VpsSelfUpdateCronField;
+    readonly hour: VpsSelfUpdateCronField;
+    readonly dayOfMonth: VpsSelfUpdateCronField;
+    readonly month: VpsSelfUpdateCronField;
+    readonly dayOfWeek: VpsSelfUpdateCronField;
+};
+
+/**
+ * One cron field parser configuration.
+ *
+ * @private type of `vpsSelfUpdateCron`
+ */
+type VpsSelfUpdateCronFieldOptions = {
+    readonly name: string;
+    readonly minimum: number;
+    readonly maximum: number;
+    readonly isSevenAllowedForSunday?: boolean;
+};
+
+/**
+ * Normalizes and validates a cron expression accepted by the automatic self-update scheduler.
+ *
+ * @param value - Raw `.env` cron expression.
+ * @returns Normalized cron expression.
+ *
+ * @private function of `vpsSelfUpdate`
+ */
+export function normalizeVpsSelfUpdateCronExpression(value: string | null | undefined): string {
+    const normalizedExpression = normalizeVpsSelfUpdateCronWhitespace(value || DEFAULT_VPS_SELF_UPDATE_CRON_EXPRESSION);
+    const cronExpression = parseVpsSelfUpdateCronExpression(normalizedExpression);
+
+    resolveNextVpsSelfUpdateCronRunFromParsedExpression(cronExpression, new Date());
+
+    return normalizedExpression;
+}
+
+/**
+ * Resolves the next run time for one automatic self-update cron expression.
+ *
+ * @param cronExpression - Valid five-field cron expression.
+ * @param afterDate - Date after which the next run must happen.
+ * @returns Next matching local server time.
+ *
+ * @private function of `vpsSelfUpdate`
+ */
+export function resolveNextVpsSelfUpdateCronRun(cronExpression: string, afterDate = new Date()): Date {
+    return resolveNextVpsSelfUpdateCronRunFromParsedExpression(
+        parseVpsSelfUpdateCronExpression(normalizeVpsSelfUpdateCronWhitespace(cronExpression)),
+        afterDate,
+    );
+}
+
+/**
+ * Collapses cron whitespace without changing field values.
+ *
+ * @param value - Raw cron expression.
+ * @returns Whitespace-normalized expression.
+ */
+function normalizeVpsSelfUpdateCronWhitespace(value: string): string {
+    return value.trim().replace(/\s+/gu, ' ') || DEFAULT_VPS_SELF_UPDATE_CRON_EXPRESSION;
+}
+
+/**
+ * Parses a five-field cron expression into numeric field sets.
+ *
+ * @param expression - Normalized cron expression.
+ * @returns Parsed cron expression.
+ */
+function parseVpsSelfUpdateCronExpression(expression: string): VpsSelfUpdateCronExpression {
+    const fields = expression.split(' ');
+    if (fields.length !== VPS_SELF_UPDATE_CRON_FIELD_COUNT) {
+        throw new NotAllowed(
+            spaceTrim(`
+                Automatic self-update cron expression \`${expression}\` is invalid.
+
+                **Use exactly five fields:** minute hour day-of-month month day-of-week.
+            `),
+        );
+    }
+
+    return {
+        minute: parseVpsSelfUpdateCronField(fields[0]!, { name: 'minute', minimum: 0, maximum: 59 }),
+        hour: parseVpsSelfUpdateCronField(fields[1]!, { name: 'hour', minimum: 0, maximum: 23 }),
+        dayOfMonth: parseVpsSelfUpdateCronField(fields[2]!, { name: 'day-of-month', minimum: 1, maximum: 31 }),
+        month: parseVpsSelfUpdateCronField(fields[3]!, { name: 'month', minimum: 1, maximum: 12 }),
+        dayOfWeek: parseVpsSelfUpdateCronField(fields[4]!, {
+            name: 'day-of-week',
+            minimum: 0,
+            maximum: 7,
+            isSevenAllowedForSunday: true,
+        }),
+    };
+}
+
+/**
+ * Parses one cron field with comma lists, ranges, and step values.
+ *
+ * @param field - Raw field value.
+ * @param options - Numeric bounds and label.
+ * @returns Parsed field values.
+ */
+function parseVpsSelfUpdateCronField(field: string, options: VpsSelfUpdateCronFieldOptions): VpsSelfUpdateCronField {
+    const values = new Set<number>();
+    const isWildcard = field === '*';
+
+    for (const part of field.split(',')) {
+        if (!part) {
+            throwInvalidVpsSelfUpdateCronField(field, options.name);
+        }
+
+        addVpsSelfUpdateCronFieldPart(values, part, options);
+    }
+
+    if (values.size === 0) {
+        throwInvalidVpsSelfUpdateCronField(field, options.name);
+    }
+
+    return { values, isWildcard };
+}
+
+/**
+ * Adds values represented by one comma-separated cron field part.
+ *
+ * @param values - Mutable field value set.
+ * @param part - Field part, for example a wildcard, `1-5`, or a stepped wildcard.
+ * @param options - Numeric bounds and label.
+ */
+function addVpsSelfUpdateCronFieldPart(
+    values: Set<number>,
+    part: string,
+    options: VpsSelfUpdateCronFieldOptions,
+): void {
+    const stepSplit = part.split('/');
+    if (stepSplit.length > 2) {
+        throwInvalidVpsSelfUpdateCronField(part, options.name);
+    }
+
+    const rangePart = stepSplit[0]!;
+    const step = stepSplit[1] === undefined ? 1 : parseVpsSelfUpdateCronNumber(stepSplit[1], options.name);
+    if (step <= 0) {
+        throwInvalidVpsSelfUpdateCronField(part, options.name);
+    }
+
+    const { start, end } = parseVpsSelfUpdateCronRange(rangePart, options);
+    for (let value = start; value <= end; value += step) {
+        values.add(normalizeVpsSelfUpdateCronFieldValue(value, options));
+    }
+}
+
+/**
+ * Parses the range portion of one cron field part.
+ *
+ * @param rangePart - Range part before optional `/step`.
+ * @param options - Numeric bounds and label.
+ * @returns Start and end range values.
+ */
+function parseVpsSelfUpdateCronRange(
+    rangePart: string,
+    options: VpsSelfUpdateCronFieldOptions,
+): { readonly start: number; readonly end: number } {
+    if (rangePart === '*') {
+        return { start: options.minimum, end: options.maximum };
+    }
+
+    const rangeSplit = rangePart.split('-');
+    if (rangeSplit.length > 2 || rangeSplit.some((value) => value === '')) {
+        throwInvalidVpsSelfUpdateCronField(rangePart, options.name);
+    }
+
+    const start = parseVpsSelfUpdateCronNumber(rangeSplit[0]!, options.name);
+    const end = rangeSplit[1] === undefined ? start : parseVpsSelfUpdateCronNumber(rangeSplit[1], options.name);
+
+    if (start > end) {
+        throwInvalidVpsSelfUpdateCronField(rangePart, options.name);
+    }
+
+    assertVpsSelfUpdateCronFieldValueInRange(start, options);
+    assertVpsSelfUpdateCronFieldValueInRange(end, options);
+
+    return { start, end };
+}
+
+/**
+ * Parses one positive cron integer token.
+ *
+ * @param value - Raw token.
+ * @param fieldName - Field name used in validation errors.
+ * @returns Parsed integer.
+ */
+function parseVpsSelfUpdateCronNumber(value: string, fieldName: string): number {
+    if (!/^\d+$/u.test(value)) {
+        throwInvalidVpsSelfUpdateCronField(value, fieldName);
+    }
+
+    return Number.parseInt(value, 10);
+}
+
+/**
+ * Asserts that one parsed cron value is inside the field bounds.
+ *
+ * @param value - Parsed value.
+ * @param options - Numeric bounds and label.
+ */
+function assertVpsSelfUpdateCronFieldValueInRange(value: number, options: VpsSelfUpdateCronFieldOptions): void {
+    if (value < options.minimum || value > options.maximum) {
+        throwInvalidVpsSelfUpdateCronField(String(value), options.name);
+    }
+}
+
+/**
+ * Normalizes Sunday from `7` to `0` in the day-of-week field.
+ *
+ * @param value - Parsed field value.
+ * @param options - Numeric bounds and label.
+ * @returns Normalized value.
+ */
+function normalizeVpsSelfUpdateCronFieldValue(value: number, options: VpsSelfUpdateCronFieldOptions): number {
+    if (options.isSevenAllowedForSunday && value === 7) {
+        return 0;
+    }
+
+    return value;
+}
+
+/**
+ * Finds the next local server time matching a parsed cron expression.
+ *
+ * @param cronExpression - Parsed cron expression.
+ * @param afterDate - Date after which the next run must happen.
+ * @returns Next matching date.
+ */
+function resolveNextVpsSelfUpdateCronRunFromParsedExpression(
+    cronExpression: VpsSelfUpdateCronExpression,
+    afterDate: Date,
+): Date {
+    const cursor = new Date(afterDate.getTime());
+    cursor.setSeconds(0, 0);
+    cursor.setMinutes(cursor.getMinutes() + 1);
+
+    for (let index = 0; index < VPS_SELF_UPDATE_CRON_LOOKAHEAD_MINUTES; index++) {
+        if (isVpsSelfUpdateCronDateMatched(cronExpression, cursor)) {
+            return new Date(cursor.getTime());
+        }
+
+        cursor.setMinutes(cursor.getMinutes() + 1);
+    }
+
+    throw new NotAllowed(
+        spaceTrim(`
+            Automatic self-update cron expression cannot be scheduled.
+
+            **Use a cron expression that matches at least one valid date.**
+        `),
+    );
+}
+
+/**
+ * Tests whether one date matches a parsed cron expression.
+ *
+ * @param cronExpression - Parsed cron expression.
+ * @param date - Candidate local server date.
+ * @returns `true` when the date matches.
+ */
+function isVpsSelfUpdateCronDateMatched(cronExpression: VpsSelfUpdateCronExpression, date: Date): boolean {
+    if (!cronExpression.minute.values.has(date.getMinutes())) {
+        return false;
+    }
+
+    if (!cronExpression.hour.values.has(date.getHours())) {
+        return false;
+    }
+
+    if (!cronExpression.month.values.has(date.getMonth() + 1)) {
+        return false;
+    }
+
+    const isDayOfMonthMatched = cronExpression.dayOfMonth.values.has(date.getDate());
+    const isDayOfWeekMatched = cronExpression.dayOfWeek.values.has(date.getDay());
+
+    if (cronExpression.dayOfMonth.isWildcard && cronExpression.dayOfWeek.isWildcard) {
+        return true;
+    }
+
+    if (cronExpression.dayOfMonth.isWildcard) {
+        return isDayOfWeekMatched;
+    }
+
+    if (cronExpression.dayOfWeek.isWildcard) {
+        return isDayOfMonthMatched;
+    }
+
+    return isDayOfMonthMatched || isDayOfWeekMatched;
+}
+
+/**
+ * Throws a branded cron validation error for one field.
+ *
+ * @param value - Invalid field value.
+ * @param fieldName - Field name used in the error message.
+ */
+function throwInvalidVpsSelfUpdateCronField(value: string, fieldName: string): never {
+    throw new NotAllowed(
+        spaceTrim(`
+            Automatic self-update cron field \`${fieldName}\` contains invalid value \`${value}\`.
+
+            **Use numbers, \`*\`, comma lists, ranges, and step values only.**
+        `),
+    );
+}

package/apps/agents-server/src/utils/vpsSelfUpdate/vpsSelfUpdateEnvironment.ts

@@ -0,0 +1,120 @@
+import { NotAllowed } from '../../../../../src/errors/NotAllowed';
+
+/**
+ * Identifier of the synthetic environment that allows targeting an arbitrary git ref.
+ *
+ * @private constant of `vpsSelfUpdate`
+ */
+export const VPS_SELF_UPDATE_CUSTOM_ENVIRONMENT_ID = 'custom' as const;
+
+/**
+ * Supported standalone VPS update environments.
+ *
+ * Order matters: it is the order presented to the super-admin in the UI.
+ *
+ * @private constant of `vpsSelfUpdate`
+ */
+export const VPS_SELF_UPDATE_ENVIRONMENTS = [
+    {
+        id: 'main',
+        branch: 'main',
+        label: 'Live',
+        description: 'Tracks the latest commit from the main development branch.',
+        isCustom: false,
+    },
+    {
+        id: 'preview',
+        branch: 'preview',
+        label: 'Preview',
+        description: 'Follows the preview branch before changes reach production.',
+        isCustom: false,
+    },
+    {
+        id: 'production',
+        branch: 'production',
+        label: 'Production',
+        description: 'Recommended stable deployment branch for standalone servers.',
+        isCustom: false,
+    },
+    {
+        id: 'lts',
+        branch: 'lts',
+        label: 'LTS',
+        description: 'Keeps the server on the long-term-support branch.',
+        isCustom: false,
+    },
+    {
+        id: VPS_SELF_UPDATE_CUSTOM_ENVIRONMENT_ID,
+        branch: '',
+        label: 'Custom',
+        description: 'Pick an arbitrary commit, tag, or branch — advanced and potentially unstable.',
+        isCustom: true,
+    },
+] as const;
+
+/**
+ * Allowed standalone VPS update environment id.
+ *
+ * @private type of `vpsSelfUpdate`
+ */
+export type VpsSelfUpdateEnvironmentId = (typeof VPS_SELF_UPDATE_ENVIRONMENTS)[number]['id'];
+
+/**
+ * One environment option returned to the browser.
+ *
+ * @private type of `vpsSelfUpdate`
+ */
+export type VpsSelfUpdateEnvironmentOption = (typeof VPS_SELF_UPDATE_ENVIRONMENTS)[number];
+
+/**
+ * Resolves one environment id or branch name to the canonical environment object.
+ *
+ * Unknown values fall back to the production environment to preserve the historical default.
+ *
+ * @param value - Raw environment id, branch name, or label.
+ * @returns Canonical environment metadata.
+ *
+ * @private function of `vpsSelfUpdate`
+ */
+export function resolveVpsSelfUpdateEnvironment(value: string | null | undefined): VpsSelfUpdateEnvironmentOption {
+    const normalizedValue = value?.trim().toLowerCase() || 'production';
+    return (
+        VPS_SELF_UPDATE_ENVIRONMENTS.find(
+            (environment) =>
+                !environment.isCustom &&
+                (environment.id === normalizedValue || environment.branch === normalizedValue),
+        ) ?? getDefaultVpsSelfUpdateEnvironment()
+    );
+}
+
+/**
+ * Returns the canonical production environment used as the default fallback.
+ *
+ * @returns Production environment option.
+ *
+ * @private function of `vpsSelfUpdate`
+ */
+export function getDefaultVpsSelfUpdateEnvironment(): VpsSelfUpdateEnvironmentOption {
+    const productionEnvironment = VPS_SELF_UPDATE_ENVIRONMENTS.find((environment) => environment.id === 'production');
+    if (!productionEnvironment) {
+        throw new NotAllowed('Production environment is missing from VPS_SELF_UPDATE_ENVIRONMENTS.');
+    }
+    return productionEnvironment;
+}
+
+/**
+ * Returns the canonical custom environment option.
+ *
+ * @returns Custom environment metadata.
+ *
+ * @private function of `vpsSelfUpdate`
+ */
+export function getCustomVpsSelfUpdateEnvironment(): VpsSelfUpdateEnvironmentOption {
+    const customEnvironment = VPS_SELF_UPDATE_ENVIRONMENTS.find(
+        (environment) => environment.id === VPS_SELF_UPDATE_CUSTOM_ENVIRONMENT_ID,
+    );
+    if (!customEnvironment) {
+        throw new NotAllowed('Custom environment is missing from VPS_SELF_UPDATE_ENVIRONMENTS.');
+    }
+    return customEnvironment;
+}

package/apps/agents-server/src/utils/vpsSelfUpdate/vpsSelfUpdateInstalledVersions.ts

@@ -0,0 +1,162 @@
+import { readdir, stat } from 'fs/promises';
+import { dirname, join, resolve } from 'path';
+import { resolveVpsEnvironmentFilePath } from '../vpsConfiguration';
+import {
+    readVpsSelfUpdateConfiguredEnvironmentValue,
+    resolveManagedPromptbookRepositoryDirectory,
+} from './vpsSelfUpdateConfiguration';
+import type { VpsSelfUpdateInstalledVersion } from './vpsSelfUpdateTypes';
+
+/**
+ * `.env` variable that stores how many installed Agents Server versions are kept by garbage collection.
+ *
+ * @private constant of `vpsSelfUpdate`
+ */
+export const AGENTS_SERVER_GC_KEEP_VERSIONS_ENV_NAME = 'AGENTS_SERVER_GC_KEEP_VERSIONS';
+
+/**
+ * Default total number of installed versions kept by garbage collection (the current one plus two previous ones).
+ *
+ * Note: [🧹] Keep in sync with the `AGENTS_SERVER_GC_KEEP_VERSIONS` default in `install.sh`.
+ *
+ * @private constant of `vpsSelfUpdate`
+ */
+export const DEFAULT_AGENTS_SERVER_GC_KEEP_VERSIONS_COUNT = 3;
+
+/**
+ * Normalizes a raw `AGENTS_SERVER_GC_KEEP_VERSIONS` value into a usable keep count.
+ *
+ * @param rawValue - Raw `.env` or process environment value.
+ * @returns Positive integer keep count, falling back to the default when the value is invalid.
+ *
+ * @private function of `vpsSelfUpdate`
+ */
+export function normalizeAgentsServerGcKeepVersionsCount(rawValue: string | null | undefined): number {
+    const trimmedValue = rawValue?.trim() || '';
+
+    if (!/^[0-9]+$/u.test(trimmedValue)) {
+        return DEFAULT_AGENTS_SERVER_GC_KEEP_VERSIONS_COUNT;
+    }
+
+    const parsedValue = Number.parseInt(trimmedValue, 10);
+    if (!Number.isSafeInteger(parsedValue) || parsedValue < 1) {
+        return DEFAULT_AGENTS_SERVER_GC_KEEP_VERSIONS_COUNT;
+    }
+
+    return parsedValue;
+}
+
+/**
+ * Reads how many installed Agents Server versions the garbage collection keeps in total.
+ *
+ * @returns Positive integer keep count configured via `AGENTS_SERVER_GC_KEEP_VERSIONS` (default 3).
+ *
+ * @private function of `vpsSelfUpdate`
+ */
+export async function readAgentsServerGcKeepVersionsCount(): Promise<number> {
+    const rawValue = await readVpsSelfUpdateConfiguredEnvironmentValue(AGENTS_SERVER_GC_KEEP_VERSIONS_ENV_NAME);
+    return normalizeAgentsServerGcKeepVersionsCount(rawValue);
+}
+
+/**
+ * Resolves the directory that holds the installed Agents Server versions.
+ *
+ * @returns Absolute releases directory path or `null` when it cannot be determined.
+ *
+ * @private function of `vpsSelfUpdate`
+ */
+export async function resolveVpsSelfUpdateReleasesDirectory(): Promise<string | null> {
+    const configuredDirectory =
+        (await readVpsSelfUpdateConfiguredEnvironmentValue('PTBK_RELEASES_DIR')) ||
+        process.env.PTBK_RELEASES_DIR?.trim() ||
+        '';
+
+    if (configuredDirectory) {
+        return resolve(configuredDirectory);
+    }
+
+    // The installer defaults `PTBK_RELEASES_DIR` to the `bin` directory next to the `.env` file.
+    const fallbackDirectory = resolve(dirname(resolveVpsEnvironmentFilePath()), 'bin');
+    try {
+        const fallbackDirectoryStats = await stat(fallbackDirectory);
+        return fallbackDirectoryStats.isDirectory() ? fallbackDirectory : null;
+    } catch {
+        return null;
+    }
+}
+
+/**
+ * Lists the Agents Server versions installed in the releases directory.
+ *
+ * Hidden entries (for example `.install-*` staging checkouts) and plain files (for example
+ * the `ptbk` launcher) are not versions and are skipped.
+ *
+ * @returns Installed versions sorted newest first, or an empty list when the releases directory is unavailable.
+ *
+ * @private function of `vpsSelfUpdate`
+ */
+export async function listVpsSelfUpdateInstalledVersions(): Promise<ReadonlyArray<VpsSelfUpdateInstalledVersion>> {
+    const releasesDirectory = await resolveVpsSelfUpdateReleasesDirectory();
+    if (!releasesDirectory) {
+        return [];
+    }
+
+    const currentRepositoryDirectory = await resolveManagedPromptbookRepositoryDirectory();
+
+    let releaseEntries;
+    try {
+        releaseEntries = await readdir(releasesDirectory, { withFileTypes: true });
+    } catch {
+        return [];
+    }
+
+    const installedVersions: Array<VpsSelfUpdateInstalledVersion> = [];
+    for (const releaseEntry of releaseEntries) {
+        if (!releaseEntry.isDirectory() || releaseEntry.name.startsWith('.')) {
+            continue;
+        }
+
+        const directoryPath = join(releasesDirectory, releaseEntry.name);
+        installedVersions.push({
+            name: releaseEntry.name,
+            directoryPath,
+            modifiedAt: await readDirectoryModifiedAt(directoryPath),
+            isCurrent: currentRepositoryDirectory !== null && resolve(directoryPath) === currentRepositoryDirectory,
+        });
+    }
+
+    return installedVersions.sort(compareInstalledVersionsNewestFirst);
+}
+
+/**
+ * Reads the last modification time of one version directory.
+ *
+ * @param directoryPath - Absolute version directory path.
+ * @returns ISO timestamp or `null` when the directory cannot be inspected.
+ */
+async function readDirectoryModifiedAt(directoryPath: string): Promise<string | null> {
+    try {
+        const directoryStats = await stat(directoryPath);
+        return directoryStats.mtime.toISOString();
+    } catch {
+        return null;
+    }
+}
+
+/**
+ * Sorts installed versions with the current one first and then newest first.
+ *
+ * @param versionA - First compared version.
+ * @param versionB - Second compared version.
+ * @returns Standard comparator result.
+ */
+function compareInstalledVersionsNewestFirst(
+    versionA: VpsSelfUpdateInstalledVersion,
+    versionB: VpsSelfUpdateInstalledVersion,
+): number {
+    if (versionA.isCurrent !== versionB.isCurrent) {
+        return versionA.isCurrent ? -1 : 1;
+    }
+
+    return (versionB.modifiedAt || '').localeCompare(versionA.modifiedAt || '');
+}

package/apps/agents-server/src/utils/vpsSelfUpdate/vpsSelfUpdateJobConstants.ts

@@ -0,0 +1,15 @@
+/**
+ * Fallback error used when a running self-update process disappears without writing a terminal status.
+ *
+ * @private constant of `vpsSelfUpdate`
+ */
+export const VPS_SELF_UPDATE_STALE_ERROR_MESSAGE =
+    'The previous background update process stopped unexpectedly before writing its final status.';
+
+/**
+ * Success step shown when the server proves a stale-looking job completed across a process restart.
+ *
+ * @private constant of `vpsSelfUpdate`
+ */
+export const VPS_SELF_UPDATE_RESTART_SUCCESS_STEP =
+    'Standalone VPS self-update finished successfully after restarting the server.';