Skip to content

Your lightweight open-source personal agent.

17.5 KB
Raw Blame
import { useEffect, useRef, useState, type ReactNode } from "react";
import { useTranslation } from "react-i18next";

import { ToggleButton } from "@/components/ui/toggle-button";
import { SettingsGroup, SettingsRow, SettingsSectionTitle, RestartRequiredNotice, RestartSettingsFooter } from "@/components/settings/shared/SettingsControls";
import { ProviderPicker } from "@/components/settings/shared/ModelControls";
import { TimezonePicker } from "@/components/settings/shared/TimezonePicker";
import { SettingsTextEditor } from "@/components/settings/shared/SettingsTextEditor";
import { SharedProxyEditor } from "@/components/settings/shared/SharedProxyEditor";
import { SettingsHint } from "@/components/settings/shared/SettingsHint";
import { ShellRuntimeControl } from "@/components/settings/system/ShellRuntimeControl";
import { IdleCompactionControl } from "@/components/settings/system/IdleCompactionControl";
import { Input } from "@/components/ui/input";
import { RUNTIME_CONFIG_FIELDS, RUNTIME_CONFIG_GROUPS, type RuntimeConfigField, type RuntimeConfigPage } from "@/components/settings/system/runtime-config-fields";
import { updateRuntimeConfigSettings } from "@/lib/api";
import { invalidateToolsCatalog } from "@/lib/tools-catalog-cache";
import type { NanobotClient } from "@/lib/nanobot-client";
import type { RuntimeConfigValue, SettingsPayload } from "@/lib/types";
import type { ApplySettingsPayload } from "@/components/settings/contracts";

type Draft = string | boolean;

function displayValue(value: RuntimeConfigValue | undefined): Draft {
  if (typeof value === "boolean") return value;
  if (Array.isArray(value)) return value.join("\n");
  return value == null ? "" : String(value);
}

export function useRuntimeConfigSettings(
  settings: SettingsPayload | null,
  client: NanobotClient,
  applyPayload: ApplySettingsPayload,
) {
  const { t } = useTranslation();
  const [drafts, setDrafts] = useState<Record<string, Draft>>({});
  const [saving, setSaving] = useState<string | null>(null);
  const [errors, setErrors] = useState<Record<string, string>>({});
  const [invalidField, setInvalidField] = useState<string | null>(null);
  const delay = useRef(600);
  const saveLatest = useRef<(group: string) => Promise<void>>(async () => {});
  const pendingGroups = useRef<string[]>([]);
  const queuedSaves = useRef<string[]>([]);
  const [saved, setSaved] = useState<Record<string, boolean>>({});
  useEffect(() => {
    if (invalidField && saving === null) document.getElementById(`runtime-${invalidField}`)?.focus();
  }, [invalidField, saving]);
  const value = (path: string): Draft => drafts[path] ?? displayValue(settings?.runtime_config?.[path]);
  const visible = (field: RuntimeConfigField) => !field.when || (Array.isArray(field.when.value)
    ? field.when.value.includes(String(value(field.when.path)))
    : value(field.when.path) === field.when.value);
  const dirty = (field: RuntimeConfigField) =>
    drafts[field.path] !== undefined && drafts[field.path] !== displayValue(settings?.runtime_config?.[field.path]);
  const discard = (group: string) => {
    setDrafts((prev) => Object.fromEntries(Object.entries(prev).filter(([path]) =>
      !RUNTIME_CONFIG_FIELDS.some((field) => field.group === group && field.path === path),
    )));
    setErrors((prev) => ({ ...prev, [group]: "" }));
    setInvalidField(null);
  };
  const change = (field: RuntimeConfigField, next: Draft) => {
    delay.current = ["boolean", "toggle", "select", "preset"].includes(field.kind) ? 0 : 600;
    setDrafts((prev) => ({ ...prev, [field.path]: next }));
    setSaved((prev) => ({ ...prev, [field.group]: false }));
    setErrors((prev) => ({ ...prev, [field.group]: "" }));
    setInvalidField(null);
  };
  const reject = (field: RuntimeConfigField, message: string) => {
    setSaved((prev) => ({ ...prev, [field.group]: false }));
    setErrors((prev) => ({ ...prev, [field.group]: message }));
    setInvalidField(field.path);
  };
  const save = async (group: string, edits: Record<string, Draft> = {}) => {
    if (!settings?.runtime_config) return;
    if (saving) {
      if (!queuedSaves.current.includes(group)) queuedSaves.current.push(group);
      return;
    }
    const editedValue = (field: RuntimeConfigField) => edits[field.path] ?? value(field.path);
    const changed = RUNTIME_CONFIG_FIELDS.filter((field) => field.group === group && visible(field)
      && editedValue(field) !== displayValue(settings.runtime_config?.[field.path]));
    if (!changed.length) return;
    const values: Record<string, RuntimeConfigValue> = {};
    for (const field of changed) {
      const raw = editedValue(field);
      if (field.kind === "idle-compaction") {
        if (!/^\d+$/.test(String(raw)) || !Number.isSafeInteger(Number(raw))) {
          reject(field, t("settings.runtimeConfig.idleCompaction.numberError"));
          return;
        }
        values[field.path] = Number(raw);
      } else if (field.kind === "number" || field.kind === "duration") {
        const maximum = field.kind === "duration" ? settings.advanced.exec_max_runtime_limit : field.max;
        const parsed = Number(raw);
        if (String(raw).trim() === "" || !Number.isFinite(parsed)
          || (field.path !== "api.timeout" && !Number.isInteger(parsed))
          || (field.min !== undefined && parsed < field.min)
          || (maximum !== undefined && parsed > maximum)) {
          setErrors((prev) => ({ ...prev, [group]: t("settings.runtimeConfig.numberError") }));
          setInvalidField(field.path);
          return;
        }
        values[field.path] = parsed;
      } else if (field.kind === "list") {
        values[field.path] = String(raw).split("\n").map((line) => line.trim()).filter(Boolean);
      } else if (field.kind === "nullable" || field.kind === "preset") {
        values[field.path] = String(raw).trim() || null;
      } else {
        values[field.path] = raw;
      }
    }
    setSaving(group);
    setErrors((prev) => ({ ...prev, [group]: "" }));
    try {
      const payload = await updateRuntimeConfigSettings(client, values);
      if (Object.keys(values).some(path => path.startsWith("tools.cli_apps.") || path === "network.proxy")) {
        invalidateToolsCatalog(client);
      }
      applyPayload(payload, { preserveAgentForm: true, preserveCapabilityForms: true });
      discard(group);
      setSaved((prev) => ({ ...prev, [group]: true }));
    } catch (error) {
      const message = (error as Error).message;
      setErrors((prev) => ({ ...prev, [group]: message }));
      setInvalidField(changed.find((field) => message.startsWith(field.path))?.path ?? null);
    } finally {
      setSaving(null);
    }
  };
  saveLatest.current = save;
  pendingGroups.current = [...new Set(RUNTIME_CONFIG_FIELDS.filter((field) =>
    visible(field) && dirty(field) && !errors[field.group]
      && !RUNTIME_CONFIG_FIELDS.some((other) => other.group === field.group && other.manual && dirty(other)),
  ).map((field) => field.group))];
  useEffect(() => {
    if (saving) return;
    const timer = window.setTimeout(() => {
      const group = queuedSaves.current.shift() ?? pendingGroups.current[0];
      if (group) void saveLatest.current(group);
    }, delay.current);
    return () => window.clearTimeout(timer);
  }, [drafts, saving]);
  const saveList = async (field: RuntimeConfigField, next: string) => {
    const payload = await updateRuntimeConfigSettings(client, {
      [field.path]: next.split("\n").map((line) => line.trim()).filter(Boolean),
    });
    applyPayload(payload, { preserveAgentForm: true, preserveCapabilityForms: true });
    setSaved((prev) => ({ ...prev, [field.group]: true }));
  };
  const commit = (field: RuntimeConfigField, next: Draft) => {
    if (next === value(field.path) && !dirty(field)) return;
    change(field, next);
    void save(field.group, { [field.path]: next });
  };
  const saveProxy = async (next: string) => {
    setSaving("proxy");
    try {
      const payload = await updateRuntimeConfigSettings(client, { "network.proxy": next.trim() || null });
      invalidateToolsCatalog(client);
      applyPayload(payload, { preserveAgentForm: true, preserveCapabilityForms: true });
      discard("proxy");
      setSaved((prev) => ({ ...prev, proxy: true }));
    } finally {
      setSaving(null);
    }
  };
  return { value, visible, dirty, discard, change, commit, reject, save, saveList, saveProxy, saving, errors, invalidField, saved };
}

export type RuntimeConfigController = ReturnType<typeof useRuntimeConfigSettings>;

export function RuntimeConfigSettings({
  page, settings, state, onRestart, isRestarting, remoteBrowserAccess, children,
}: {
  page: RuntimeConfigPage;
  settings: SettingsPayload;
  state: RuntimeConfigController;
  onRestart?: () => void;
  isRestarting: boolean;
  remoteBrowserAccess: boolean;
  children?: ReactNode;
}) {
  const { t } = useTranslation();
  const tr = (key: string) => t(`settings.runtimeConfig.${key}`);
  if (!settings.runtime_config) return <div className="settings-stack">
    <p className="settings-editor text-[13px] leading-5 text-muted-foreground">{tr("unavailable")}</p>
    {children}
  </div>;
  const groups = RUNTIME_CONFIG_GROUPS.filter((group) => group.page === page);
  const restartPending = settings.restart_required_sections?.includes("runtime")
    || (settings.requires_restart && Object.values(state.saved).some(Boolean));
  return (
    <div className="settings-stack">
      {restartPending && onRestart ? <RestartRequiredNotice message={t("settings.status.savedRestartApply")}
        onRestart={onRestart} isRestarting={isRestarting} /> : null}
      {groups.map((group) => {
        if (group.enabledBy && state.value(group.enabledBy) === false) return null;
        if (group.id === "chat") return <div key={group.id}>{children}</div>;
        const fields = RUNTIME_CONFIG_FIELDS.filter((field) => field.group === group.id);
        const dirty = fields.filter(state.visible).some(state.dirty);
        const title = tr(`groups.${group.id}.title`);
        const errorId = `runtime-error-${group.id}`;
        const inlineError = fields.some((field) => field.kind === "duration" && state.invalidField === field.path);
        const section = (
          <section key={group.id} aria-label={title}>
            <SettingsSectionTitle>{group.id === "proxy"
              ? <SettingsHint description={tr("fields.network_proxy.help")}>{title}</SettingsHint>
              : title}</SettingsSectionTitle>
            <form noValidate onSubmit={(event) => { event.preventDefault(); void state.save(group.id); }}
              onBlur={(event) => {
                if (event.relatedTarget && event.currentTarget.contains(event.relatedTarget)) return;
                if (fields.some((field) => field.kind === "idle-compaction" && state.dirty(field))) {
                  void state.save(group.id);
                }
              }}>
              <fieldset disabled={state.saving === group.id || isRestarting} className="min-w-0">
                <legend className="sr-only">{title}</legend>
                <button type="submit" hidden />
                <SettingsGroup>
                  {fields.filter(state.visible).map((field) => {
                    const id = `runtime-${field.path}`;
                    const current = state.value(field.path);
                    if (field.kind === "idle-compaction") return (
                      <IdleCompactionControl key={field.path} id={id} value={String(current)}
                        savedMinutes={Number(settings.runtime_config?.[field.path])}
                        disabled={state.saving === group.id || isRestarting}
                        errorId={state.invalidField === field.path ? errorId : undefined}
                        onChange={(next) => state.change(field, next)}
                        onCommit={(next) => state.commit(field, next)} />
                    );
                    const key = field.path.replaceAll(".", "_");
                    const text = tr(`fields.${key}.label`);
                    const help = tr(`fields.${key}.help`);
                    const disabled = (field.path === "agents.defaults.timezone" && state.value("agents.defaults.timezone_mode") === "auto")
                      || (field.path === "tools.webui_allow_remote_package_install" && remoteBrowserAccess);
                    const common = {
                      id, disabled, "aria-label": text, "aria-describedby": `${id}-help${state.invalidField === field.path ? ` ${errorId}` : ""}`,
                      "aria-invalid": state.invalidField === field.path || undefined,
                    };
                    const options = field.kind === "preset"
                      ? ["", ...new Set(["default", ...settings.model_presets.map((preset) => preset.name)])]
                      : [...field.options ?? []];
                    // Keep a configured preset visible if it is no longer available.
                    if (field.kind === "preset" && current && !options.includes(String(current))) options.push(String(current));
                    if (field.path === "network.proxy") return (
                      <div key={field.path} className="px-4 py-4 sm:px-5">
                        <span id={`${id}-help`} className="sr-only">{help}</span>
                        <SharedProxyEditor value={String(current)} addressProps={common}
                          disabled={disabled || state.saving !== null || isRestarting}
                          onChange={(next) => state.change(field, next)} />
                      </div>
                    );
                    return (
                      <SettingsRow key={field.path} title={text} description={help}>
                        <span id={`${id}-help`} className="sr-only">{help}</span>
                        {field.kind === "boolean" || field.kind === "toggle" ? (
                          <ToggleButton {...common} checked={field.kind === "toggle" ? current === field.options?.[1] : current === true} label={text}
                            onChange={(next) => state.change(field, field.kind === "toggle" ? field.options![next ? 1 : 0] : next)} />
                        ) : (
                          <div className="w-full">
                            {field.path === "agents.defaults.timezone" ? (
                              <TimezonePicker {...common} value={String(current)} onChange={(next) => state.change(field, next)} />
                            ) : field.kind === "duration" ? (
                              <ShellRuntimeControl value={String(current)} maximum={settings.advanced.exec_max_runtime_limit}
                                controlProps={{ ...common, disabled: disabled || state.saving === group.id || isRestarting }}
                                onChange={(next) => state.change(field, next)}
                                error={state.invalidField === field.path && state.errors[group.id]
                                  ? { id: errorId, message: state.errors[group.id] } : undefined}
                                onReject={(message) => state.reject(field, message)} />
                            ) : field.kind === "list" ? (
                              <SettingsTextEditor id={id} title={text} description={help} value={String(current)}
                                disabled={disabled || state.saving !== null || isRestarting}
                                onSave={(next) => state.saveList(field, next)} />
                            ) : field.kind === "select" || field.kind === "preset" ? (
                              <ProviderPicker triggerProps={{ ...common, disabled: disabled || state.saving === group.id || isRestarting }}
                                value={String(current) || "__none__"} emptyLabel={tr("none")}
                                providers={options.map((option) => ({ name: option || "__none__", label:
                                  !option ? tr(field.kind === "preset" ? "activeModel" : "none")
                                    : ["auto", "manual", "standard", "persistent"].includes(option) ? tr(option) : option,
                                }))}
                                onChange={(next) => state.change(field, next === "__none__" ? "" : next)} />
                            ) : (
                              <Input {...common} type={field.kind === "number" ? "number" : "text"}
                                min={field.min} max={field.max} step={field.path === "api.timeout" ? "any" : 1}
                                value={String(current)} className="h-9 rounded-full text-[13px]" autoComplete="off"
                                onChange={(event) => state.change(field, event.target.value)} />
                            )}
                          </div>
                        )}
                      </SettingsRow>
                    );
                  })}
                  <RestartSettingsFooter autoSave={!fields.some((field) => field.manual && state.dirty(field))} dirty={dirty} saving={state.saving === group.id}
                    error={Boolean(state.errors[group.id])}
                    disabled={state.saving === group.id || isRestarting}
                    pendingRestart={false}
                    message={state.saved[group.id] && !dirty ? tr("saved") : undefined}
                    onSave={() => void state.save(group.id)} onReset={() => state.discard(group.id)}
                    onRestart={onRestart} isRestarting={isRestarting} />
                </SettingsGroup>
              </fieldset>
              {state.errors[group.id] && !inlineError ? <p id={errorId} role="alert" className="mt-2 break-words px-1 text-[12px] text-destructive">{state.errors[group.id]}</p> : null}
            </form>
          </section>
        );
        return section;
      })}
    </div>
  );
}