Skip to content

πŸ™Œ OpenHands: AI-Driven Development

11.1 KB
Raw Blame
import {
  resolveAutomationSetupPlugins,
  serializeAutomationSetupPluginList,
} from "#/api/automation-setup-plugins";
import type {
  AutomationSetupDraft,
  AutomationSetupField,
  AutomationSetupFieldUpdateSource,
  AutomationSetupFormPatch,
  AutomationSetupFormValues,
  AutomationSetupKind,
  AutomationSetupPatchResult,
  AutomationSetupTriggerKind,
  AutomationSetupFrequency,
} from "#/api/automation-setup-types";
import type { AutomationRepository } from "#/types/automation";
import { readAutomationRepositories } from "#/utils/automation-preset-sources";

const AUTOMATION_FORM_SESSION_CHANGED_EVENT =
  "openhands:automation-form-session-changed";

export const PENDING_AUTOMATION_SETUP_ID = "pending-new-automation";

export function isPendingAutomationSetupId(
  conversationId: string | null | undefined,
): boolean {
  return conversationId === PENDING_AUTOMATION_SETUP_ID;
}
const AUTOMATION_SETUP_KINDS: AutomationSetupKind[] = [
  "prompt",
  "plugin",
  "custom",
];
const AUTOMATION_SETUP_TRIGGER_KINDS: AutomationSetupTriggerKind[] = [
  "cron",
  "event",
];
const AUTOMATION_SETUP_FREQUENCIES: AutomationSetupFrequency[] = [
  "once",
  "hourly",
  "daily",
  "weekdays",
  "weekly",
  "custom",
];
const STRING_FIELDS = [
  "name",
  "prompt",
  "repository",
  "pluginSource",
  "pluginRef",
  "pluginList",
  "customCode",
  "entrypoint",
  "setupScriptPath",
  "setupScript",
  "time",
  "scheduleDateTime",
  "timezone",
  "weekday",
  "customSchedule",
  "eventSource",
  "eventKey",
  "eventFilter",
  "model",
  "agentProfileId",
  "timeoutSeconds",
] as const satisfies readonly AutomationSetupField[];

const sessions = new Map<string, AutomationSetupDraft>();

function isAutomationSetupKind(value: unknown): value is AutomationSetupKind {
  return (
    typeof value === "string" &&
    AUTOMATION_SETUP_KINDS.includes(value as AutomationSetupKind)
  );
}

function normalizeString(value: unknown): string | null {
  return typeof value === "string" ? value : null;
}

function normalizeFormPatch(value: unknown): AutomationSetupFormPatch {
  if (typeof value !== "object" || value === null || Array.isArray(value)) {
    return {};
  }

  const source = value as Record<string, unknown>;
  const form: AutomationSetupFormPatch = {};
  for (const field of STRING_FIELDS) {
    const fieldValue = normalizeString(source[field]);
    if (fieldValue !== null) form[field] = fieldValue;
  }
  if (isAutomationSetupKind(source.kind)) form.kind = source.kind;
  if (
    typeof source.triggerKind === "string" &&
    AUTOMATION_SETUP_TRIGGER_KINDS.includes(
      source.triggerKind as AutomationSetupTriggerKind,
    )
  ) {
    form.triggerKind = source.triggerKind as AutomationSetupTriggerKind;
  }
  if (
    typeof source.frequency === "string" &&
    AUTOMATION_SETUP_FREQUENCIES.includes(
      source.frequency as AutomationSetupFrequency,
    )
  ) {
    form.frequency = source.frequency as AutomationSetupFrequency;
  }
  if (typeof source.showTimeout === "boolean") {
    form.showTimeout = source.showTimeout;
  }
  return form;
}

function normalizeFieldMetadata(
  value: AutomationSetupDraft["fieldMetadata"],
): AutomationSetupDraft["fieldMetadata"] {
  if (typeof value !== "object" || value === null || Array.isArray(value)) {
    return undefined;
  }

  const metadata: AutomationSetupDraft["fieldMetadata"] = {};
  for (const [field, entry] of Object.entries(value)) {
    if (
      typeof entry === "object" &&
      entry !== null &&
      !Array.isArray(entry) &&
      (entry.updatedBy === "agent" || entry.updatedBy === "user") &&
      typeof entry.updatedAt === "string" &&
      typeof entry.userDirty === "boolean"
    ) {
      metadata[field as AutomationSetupField] = entry;
    }
  }
  return Object.keys(metadata).length > 0 ? metadata : undefined;
}

function normalizeDraft(value: AutomationSetupDraft): AutomationSetupDraft {
  const form = normalizeFormPatch(value.form);
  const prompt = form.prompt ?? value.prompt;
  const kind = form.kind ?? value.kind;
  if (typeof prompt !== "string" || !isAutomationSetupKind(kind)) {
    return { prompt: "", kind: "prompt" };
  }

  const plugins = Array.isArray(value.plugins)
    ? value.plugins.filter(
        (plugin): plugin is string => typeof plugin === "string",
      )
    : [];
  const pluginEntries = resolveAutomationSetupPlugins(form, plugins);
  const pluginSources = pluginEntries
    .map((entry) => entry.source.trim())
    .filter(Boolean);
  const normalizedForm: AutomationSetupFormPatch = {
    ...form,
    prompt,
    kind,
    pluginList:
      pluginEntries.length > 0
        ? serializeAutomationSetupPluginList(pluginEntries)
        : "",
    pluginSource: pluginEntries[0]?.source ?? "",
    pluginRef: pluginEntries[0]?.ref ?? "",
  };
  const normalizedPlugins = pluginSources;
  const fieldMetadata = normalizeFieldMetadata(value.fieldMetadata);
  const editingAutomationId =
    typeof value.editingAutomationId === "string"
      ? value.editingAutomationId.trim()
      : "";
  const existingCustomTarballPath =
    typeof value.existingCustomTarballPath === "string"
      ? value.existingCustomTarballPath.trim()
      : "";
  const existingRepositories = readAutomationRepositories(
    value.existingRepositories,
  );
  const serverDraftId =
    typeof value.serverDraftId === "string" ? value.serverDraftId.trim() : "";
  const materializedAutomationId =
    typeof value.materializedAutomationId === "string"
      ? value.materializedAutomationId.trim()
      : null;
  const appliedAgentEventIds = Array.isArray(value.appliedAgentEventIds)
    ? [
        ...new Set(
          value.appliedAgentEventIds.filter((id) => typeof id === "string"),
        ),
      ]
    : undefined;

  return {
    prompt,
    kind,
    ...(normalizedPlugins.length > 0 ? { plugins: normalizedPlugins } : {}),
    form: normalizedForm,
    ...(editingAutomationId ? { editingAutomationId } : {}),
    ...(existingCustomTarballPath ? { existingCustomTarballPath } : {}),
    ...(existingRepositories.length > 0 ? { existingRepositories } : {}),
    ...(value.canUpdateRepositories === true
      ? { canUpdateRepositories: true }
      : {}),
    ...(serverDraftId ? { serverDraftId } : {}),
    ...(materializedAutomationId ? { materializedAutomationId } : {}),
    ...(fieldMetadata ? { fieldMetadata } : {}),
    ...(appliedAgentEventIds && appliedAgentEventIds.length > 0
      ? { appliedAgentEventIds }
      : {}),
  };
}

function isEmptyValue(value: AutomationSetupFormValues[AutomationSetupField]) {
  if (typeof value === "string") return value.trim() === "";
  return value === false;
}

function eventDetail(
  conversationId: string,
  draft: AutomationSetupDraft | null,
  result?: AutomationSetupPatchResult,
) {
  return { conversationId, draft, result };
}

function notifySessionChanged(
  conversationId: string,
  draft: AutomationSetupDraft | null,
  result?: AutomationSetupPatchResult,
) {
  if (typeof window === "undefined") return;
  window.dispatchEvent(
    new CustomEvent(AUTOMATION_FORM_SESSION_CHANGED_EVENT, {
      detail: eventDetail(conversationId, draft, result),
    }),
  );
}

export function initializeAutomationFormSession(
  conversationId: string,
  draft: AutomationSetupDraft,
) {
  sessions.set(conversationId, normalizeDraft(draft));
}

/** Record the repositories an edited automation clones after a save. */
export function setAutomationFormSessionRepositories(
  conversationId: string,
  repositories: AutomationRepository[],
) {
  const existing = sessions.get(conversationId);
  if (!existing) return;
  sessions.set(
    conversationId,
    normalizeDraft({ ...existing, existingRepositories: repositories }),
  );
}

export function getAutomationFormSession(
  conversationId: string | null | undefined,
): AutomationSetupDraft | null {
  if (!conversationId) return null;
  return sessions.get(conversationId) ?? null;
}

export function patchAutomationFormSession(
  conversationId: string,
  patch: AutomationSetupFormPatch,
  options: {
    source: AutomationSetupFieldUpdateSource;
    overwriteUserEdits?: boolean;
    eventId?: string | null;
    updatedAt?: string;
  },
): AutomationSetupPatchResult {
  const existing = sessions.get(conversationId);
  const result: AutomationSetupPatchResult = {
    applied: [],
    skipped: [],
    duplicate: false,
  };
  if (!existing) return result;

  if (
    options.source === "agent" &&
    options.eventId &&
    existing.appliedAgentEventIds?.includes(options.eventId)
  ) {
    return { ...result, duplicate: true };
  }

  const normalizedPatch = normalizeFormPatch(patch);
  const nextForm: AutomationSetupFormPatch = { ...(existing.form ?? {}) };
  const nextMetadata: NonNullable<AutomationSetupDraft["fieldMetadata"]> = {
    ...(existing.fieldMetadata ?? {}),
  };
  const updatedAt = options.updatedAt ?? new Date().toISOString();

  for (const [fieldName, value] of Object.entries(normalizedPatch)) {
    const field = fieldName as AutomationSetupField;
    const currentValue = nextForm[field];
    const metadata = nextMetadata[field];
    const userDirty = metadata?.userDirty === true;
    if (
      options.source === "agent" &&
      userDirty &&
      !options.overwriteUserEdits
    ) {
      result.skipped.push(field);
      continue;
    }
    if (
      options.source === "agent" &&
      metadata?.updatedAt &&
      metadata.updatedAt > updatedAt &&
      !options.overwriteUserEdits
    ) {
      result.skipped.push(field);
      continue;
    }
    if (
      options.source === "agent" &&
      currentValue !== undefined &&
      !isEmptyValue(currentValue) &&
      userDirty &&
      !options.overwriteUserEdits
    ) {
      result.skipped.push(field);
      continue;
    }

    (nextForm as Record<string, unknown>)[field] = value;
    nextMetadata[field] = {
      updatedBy: options.source,
      updatedAt,
      userDirty: options.source === "user" || userDirty,
    };
    result.applied.push(field);
  }

  const nextDraft = normalizeDraft({
    ...existing,
    form: nextForm,
    prompt: nextForm.prompt ?? existing.prompt,
    kind: nextForm.kind ?? existing.kind,
    fieldMetadata: nextMetadata,
    appliedAgentEventIds:
      options.source === "agent" && options.eventId
        ? [...(existing.appliedAgentEventIds ?? []), options.eventId]
        : existing.appliedAgentEventIds,
  });

  sessions.set(conversationId, nextDraft);
  notifySessionChanged(conversationId, nextDraft, result);
  return result;
}

export function subscribeAutomationFormSession(
  conversationId: string,
  listener: (
    draft: AutomationSetupDraft | null,
    result?: AutomationSetupPatchResult,
  ) => void,
): () => void {
  if (typeof window === "undefined") return () => {};

  const handler = (event: Event) => {
    const detail = (event as CustomEvent<ReturnType<typeof eventDetail>>)
      .detail;
    if (detail?.conversationId !== conversationId) return;
    listener(detail.draft, detail.result);
  };
  window.addEventListener(AUTOMATION_FORM_SESSION_CHANGED_EVENT, handler);
  return () =>
    window.removeEventListener(AUTOMATION_FORM_SESSION_CHANGED_EVENT, handler);
}

export function clearAutomationFormSession(conversationId: string) {
  sessions.delete(conversationId);
  notifySessionChanged(conversationId, null);
}