Skip to content

Self-hosted, Self-Improving, Federated Everything App — dev management, agent orchestration, persistent mind, digital twin, second brain, and creative pipeline from a single dashboard over Tailscale to port the user into the OS

12.4 KB
Raw Blame
import { useCallback, useEffect, useMemo, useState } from 'react';
import { CalendarClock, Loader2, AlertTriangle, Trash2 } from 'lucide-react';
import { getSettings, patchSettingsSlice } from '../../services/apiSystem';
import { getCosConfig } from '../../services/apiAgents';
import { describeCron } from '../../utils/cronHelpers';
import { providerDisplayName, providerModelLabel, assignmentModelOptions, resolveSeriesRunLlm, resolveCliEffort } from '../../utils/providers';
import BrailleSpinner from '../BrailleSpinner';
import CronInput from '../CronInput';
import ProviderModelSelector from '../ProviderModelSelector';
import toast from '../ui/Toast';

/**
 * Scheduled Series Autopilot setup (#2174).
 *
 * Lets the user register a cron schedule so this series runs its autopilot
 * unattended (overnight, autonovel-style). This is the AI Provider Usage
 * Policy's sanctioned "scheduled automation" exception, so the UI is an
 * explicit, consent-gated setup that:
 *  - names the provider/model the scheduled run will use (with a picker to
 *    change it — falls back to the series' own configured provider),
 *  - names the CoS autonomy mode + daily action-budget cap the run is gated by,
 *  - keeps the enable toggle OFF by default (no schedule until the user opts in).
 *
 * Schedules are stored MACHINE-LOCALLY in `settings.seriesAutopilot.schedules`
 * (settings.json doesn't federate) — a schedule on the federated series record
 * would double-run the same series across sync peers.
 */
export default function SeriesAutopilotSchedule({ series, providers = [], activeProviderId = null }) {
  const seriesId = series?.id;
  const [loaded, setLoaded] = useState(false);
  const [saving, setSaving] = useState(false);
  const [editingCron, setEditingCron] = useState(false);

  // The persisted schedule entry for THIS series (null when none configured).
  const [entry, setEntry] = useState(null);
  // Context for the consent copy. The provider list comes from AutopilotPanel
  // (which needs it for its own run-provider picker) rather than being fetched
  // again here — one `/providers` round trip per panel, and the two blocks of
  // consent copy can't name different providers.
  const [cosMode, setCosMode] = useState(null);
  const [cosBudget, setCosBudget] = useState(null); // maxActionsPerDay or null (unlimited)

  // CoS autonomy/budget — series-independent, so fetch once, not per series switch.
  useEffect(() => {
    let canceled = false;
    getCosConfig({ silent: true }).catch(() => null).then((cos) => {
      if (canceled) return;
      setCosMode(cos?.domainAutonomy?.cos ?? 'execute');
      const cap = cos?.domainBudgets?.cos?.maxActionsPerDay;
      setCosBudget(Number.isFinite(cap) && cap > 0 ? cap : null);
    });
    return () => { canceled = true; };
  }, []);

  // This series' persisted schedule entry — reloads when the series changes.
  // Reset first so a switch can't briefly show (and let the user save) the
  // previous series' schedule under the new seriesId before the fetch resolves.
  useEffect(() => {
    let canceled = false;
    setLoaded(false);
    setEntry(null);
    getSettings({ silent: true }).catch(() => null).then((settings) => {
      if (canceled) return;
      const schedules = settings?.seriesAutopilot?.schedules;
      setEntry(Array.isArray(schedules) ? schedules.find((s) => s?.seriesId === seriesId) || null : null);
      setLoaded(true);
    });
    return () => { canceled = true; };
  }, [seriesId]);

  // Effective provider/model the scheduled run will use: schedule override →
  // series' own llm → the active provider. Shares `resolveSeriesRunLlm` with the
  // Autopilot Options picker (and mirrors startSeriesAutopilot's own resolution)
  // so both surfaces name the same thing.
  const { provider: effProviderId, model: effModel } = resolveSeriesRunLlm(series, {
    overrideProvider: entry?.provider,
    overrideModel: entry?.model,
    activeProviderId,
  });
  const providerLabel = (id) => providerDisplayName(providers, id, '—');
  const providerModels = useMemo(
    () => assignmentModelOptions(null, providers, effProviderId),
    [providers, effProviderId],
  );
  // The level a pinned effort actually runs as — the server clamps one the
  // resolved provider/model doesn't offer, and emits nothing for a provider with
  // no effort control. Naming the clamped value keeps the consent copy honest.
  const effProvider = providers.find((p) => p.id === effProviderId);
  const effectiveEffort = resolveCliEffort(entry?.effort, effProvider, effModel);

  // Persist a mutated entry for this series, preserving every OTHER series'
  // schedule. Re-reads the freshest schedules array so a sibling series edited
  // elsewhere isn't clobbered, then replaces/removes just this series' element.
  const persist = useCallback(async (nextEntry) => {
    setSaving(true);
    const stamped = nextEntry ? { ...nextEntry, seriesId } : null;
    const settings = await getSettings({ silent: true }).catch(() => null);
    const others = Array.isArray(settings?.seriesAutopilot?.schedules)
      ? settings.seriesAutopilot.schedules.filter((s) => s?.seriesId !== seriesId)
      : [];
    const next = stamped ? [...others, stamped] : others;
    const ok = await patchSettingsSlice('seriesAutopilot', { schedules: next }, { silent: true })
      .then(() => true)
      .catch((err) => { toast.error(err.message || 'Failed to save schedule'); return false; });
    if (ok) setEntry(stamped);
    setSaving(false);
    return ok;
  }, [seriesId]);

  // patch-merge helpers — the provider/model/enable controls render only inside
  // the `hasCron` block, so `entry` is a full object there; `saveCron`'s spread
  // of a possibly-null entry is a spec-safe no-op.
  const saveCron = async (cron) => {
    setEditingCron(false);
    // Setting a cron never auto-enables — the user still flips the toggle (consent).
    await persist({ ...entry, cron });
  };
  const toggleEnabled = async (enabled) => {
    if (enabled && !entry?.cron) {
      toast.error('Set a schedule time first');
      return;
    }
    await persist({ ...entry, enabled });
  };
  // Picking a provider clears the model AND the effort: both ladders are
  // provider-specific (and Antigravity's is per-model), so a carried-over pin
  // could name a level the new provider never offers.
  const setProvider = async (provider) => persist({ ...entry, provider: provider || undefined, model: undefined, effort: undefined });
  const setModel = async (model) => persist({ ...entry, model: model || undefined });
  const setEffort = async (effort) => persist({ ...entry, effort: effort || undefined });
  // Stored as a plain boolean; `runOptionsFor` forwards only an explicit `true`,
  // so an unticked schedule still leaves each stage's own pinned provider/model
  // (from the Prompts page) in effect instead of overriding it.
  const setOverrideStagePins = async (on) => persist({ ...entry, overrideStagePins: on });

  const removeSchedule = async () => {
    await persist(null);
    setEditingCron(false);
  };

  if (!seriesId) return null;

  const enabled = !!entry?.enabled;
  const hasCron = !!entry?.cron;

  return (
    <div className="border-t border-port-border px-3 py-3 flex flex-col gap-2.5">
      <div className="flex items-center gap-2 flex-wrap">
        <CalendarClock size={14} className="text-port-accent" />
        <span className="text-sm font-medium text-white">Scheduled runs</span>
        <span className="text-xs text-gray-500">progress this series unattended on a timer</span>
        {saving ? <Loader2 size={12} className="animate-spin text-gray-500 ml-auto" /> : null}
      </div>

      {!loaded ? (
        <p className="text-xs"><BrailleSpinner text="Loading…" /></p>
      ) : (
        <>
          {/* Schedule time */}
          <div className="flex items-center gap-2 flex-wrap text-xs">
            <span className="text-gray-400">When:</span>
            {editingCron ? (
              <CronInput
                value={entry?.cron || '0 3 * * *'}
                onSave={saveCron}
                onCancel={() => setEditingCron(false)}
              />
            ) : (
              <>
                <span className="text-gray-200">{hasCron ? describeCron(entry.cron) : 'not set'}</span>
                <button
                  type="button"
                  onClick={() => setEditingCron(true)}
                  className="px-2 py-0.5 rounded border border-port-border bg-port-bg text-gray-300 hover:border-port-accent/40 hover:text-white"
                >
                  {hasCron ? 'Change' : 'Set schedule'}
                </button>
                {hasCron ? (
                  <button
                    type="button"
                    onClick={removeSchedule}
                    disabled={saving}
                    className="inline-flex items-center gap-1 px-2 py-0.5 rounded border border-port-border bg-port-bg text-gray-400 hover:text-port-error hover:border-port-error/40 disabled:opacity-40"
                    title="Remove schedule"
                  >
                    <Trash2 size={11} /> Remove
                  </button>
                ) : null}
              </>
            )}
          </div>

          {/* Consent context: names the provider/model + the budget/autonomy gate. */}
          {hasCron ? (
            <div className="rounded-lg border border-port-border bg-port-bg/60 p-2.5 flex flex-col gap-2">
              <p className="text-[11px] text-gray-400 leading-relaxed">
                Each scheduled run calls your AI provider automatically. It runs as{' '}
                <span className="text-gray-200 font-medium">{providerModelLabel(providers, effProviderId, effModel)}</span>
                {effectiveEffort ? (
                  <> at <span className="text-gray-200 font-medium">{effectiveEffort}</span> reasoning effort</>
                ) : null}
                , and is gated by the CoS autonomy mode{' '}
                <span className={`font-medium ${cosMode === 'off' ? 'text-port-error' : 'text-gray-200'}`}>{cosMode || 'execute'}</span>
                {' '}and the CoS daily action budget{' '}
                <span className="text-gray-200 font-medium">{cosBudget ? `(${cosBudget} actions/day)` : '(no cap set)'}</span>.
                {' '}Runs pause and notify you instead of retrying forever.
              </p>

              <div className="max-w-md">
                <ProviderModelSelector
                  providers={providers}
                  selectedProviderId={entry?.provider ?? ''}
                  effectiveProviderId={effProviderId}
                  selectedModel={entry?.model || ''}
                  availableModels={providerModels}
                  onProviderChange={setProvider}
                  onModelChange={setModel}
                  effort={entry?.effort || ''}
                  onEffortChange={setEffort}
                  label="Override provider for scheduled runs"
                  compact
                  alwaysShowModel
                  emptyProviderOption={`Use series default (${providerLabel(series?.llm?.provider || activeProviderId)})`}
                  emptyModelOption="Default model"
                />
                <label className="flex items-center gap-2 text-xs text-gray-300 pt-1.5">
                  <input
                    type="checkbox"
                    checked={entry?.overrideStagePins === true}
                    disabled={saving}
                    onChange={(e) => setOverrideStagePins(e.target.checked)}
                  />
                  Use it for every stage (ignore Prompts stage pins)
                </label>
              </div>

              {cosMode === 'off' ? (
                <p className="text-[11px] text-port-warning flex items-start gap-1">
                  <AlertTriangle size={12} className="mt-0.5 shrink-0" />
                  CoS autonomy is off — scheduled runs will be skipped until you set it to dry-run or execute in CoS settings.
                </p>
              ) : null}

              {/* Enable toggle — OFF by default; turning it ON is the consent. */}
              <label className="flex items-center gap-2 text-xs text-gray-200 pt-0.5">
                <input
                  type="checkbox"
                  checked={enabled}
                  disabled={saving || !hasCron}
                  onChange={(e) => toggleEnabled(e.target.checked)}
                />
                <span className="font-medium">Enable scheduled autopilot for this series</span>
              </label>
            </div>
          ) : null}
        </>
      )}
    </div>
  );
}