Skip to content

AI-native knowledge base & Evernote/Obsidian alternative with instant sync & native MCP. Free on Cloudflare or self-hosted via Docker.

9.6 KB
Raw Blame
import { z } from "zod";
import type { TiptapDoc } from "./content";
import {
  AI_ACTIONS,
  AI_PROMPT_PARAMETER_KINDS,
  AI_PROMPT_RESULT_MODES,
} from "./ai-assistant";
import type { AiPromptTemplate, MemoDetail, Notebook, Resource } from "./types";

export const EDGEEVER_ZIP_FORMAT = "edgeever-zip";
export const EDGEEVER_ZIP_FORMAT_VERSION = 2;

export type JsonBackupManifest = {
  format: typeof EDGEEVER_ZIP_FORMAT;
  formatVersion: 1 | typeof EDGEEVER_ZIP_FORMAT_VERSION;
  schemaVersion: number;
  edgeeverVersion: string;
  buildId: string;
  exportedAt: string;
  includesTrash: false;
  counts: {
    notebooks: number;
    memos: number;
    revisions: number;
    resources: number;
    prompts?: number;
  };
};

export type JsonBackupNotebook = Omit<Notebook, "memoCount" | "lastMemoUpdatedAt">;

export type JsonBackupRevision = {
  id: string;
  memoId: string;
  revision: number;
  title: string | null;
  tags: string[];
  contentJson: TiptapDoc;
  contentMarkdown: string;
  contentText: string;
  contentHash: string;
  createdBy: string;
  createdAt: string;
};

export type JsonBackupResource = Omit<Resource, "url"> & {
  archivePath: string;
};

export type JsonBackupMemo = {
  memo: MemoDetail;
  revisions: JsonBackupRevision[];
  resources: JsonBackupResource[];
};

export type JsonBackupAiPrompt = AiPromptTemplate;

const DateTimeSchema = z.string().datetime();

export const JsonBackupManifestSchema = z.object({
  format: z.literal(EDGEEVER_ZIP_FORMAT),
  formatVersion: z.union([z.literal(1), z.literal(EDGEEVER_ZIP_FORMAT_VERSION)]),
  schemaVersion: z.number().int().positive(),
  edgeeverVersion: z.string().trim().min(1),
  buildId: z.string().trim().min(1),
  exportedAt: DateTimeSchema,
  includesTrash: z.literal(false),
  counts: z.object({
    notebooks: z.number().int().min(0),
    memos: z.number().int().min(0),
    revisions: z.number().int().min(0),
    resources: z.number().int().min(0),
    prompts: z.number().int().min(0).optional(),
  }),
});

export const JsonBackupNotebookSchema = z.object({
  id: z.string().trim().min(1),
  parentId: z.string().trim().min(1).nullable(),
  name: z.string().trim().min(1).max(80),
  slug: z.string().nullable(),
  icon: z.string().nullable(),
  color: z.string().nullable(),
  textColor: z.string().nullable().optional(),
  colorTarget: z.enum(["icon", "name", "both"]).optional(),
  isBold: z.boolean().optional(),
  iconInverted: z.boolean().optional(),
  rowInverted: z.boolean().optional(),
  sortOrder: z.number().int(),
  createdAt: DateTimeSchema,
  updatedAt: DateTimeSchema,
});

const JsonBackupRevisionSchema = z.object({
  id: z.string().trim().min(1),
  memoId: z.string().trim().min(1),
  revision: z.number().int().min(0),
  title: z.string().nullable(),
  tags: z.array(z.string()),
  contentJson: z.unknown(),
  contentMarkdown: z.string(),
  contentText: z.string(),
  contentHash: z.string(),
  createdBy: z.string(),
  createdAt: DateTimeSchema,
});

const MemoDetailSchema = z.object({
  id: z.string().trim().min(1),
  notebookId: z.string().trim().min(1),
  title: z.string().nullable(),
  excerpt: z.string(),
  tags: z.array(z.string()),
  isPinned: z.boolean(),
  isArchived: z.boolean(),
  isDeleted: z.boolean(),
  revision: z.number().int().min(0),
  createdAt: DateTimeSchema,
  updatedAt: DateTimeSchema,
  deletedAt: DateTimeSchema.nullable(),
  contentJson: z.unknown(),
  contentMarkdown: z.string(),
  contentText: z.string(),
  contentHash: z.string(),
  sourceMemoIds: z.array(z.string()),
  mergeSourceCount: z.number().int().min(0),
  mergedIntoMemoId: z.string().nullable(),
});

export const JsonBackupMemoSchema = z.object({
  memo: MemoDetailSchema,
  revisions: z.array(JsonBackupRevisionSchema),
  resources: z.array(z.object({
    id: z.string().trim().min(1),
    memoId: z.string().trim().min(1),
    originalMemoId: z.string().nullable(),
    kind: z.enum(["image", "attachment"]),
    mimeType: z.string().nullable(),
    filename: z.string().nullable(),
    byteSize: z.number().int().min(0),
    sha256: z.string().nullable(),
    width: z.number().int().positive().nullable(),
    height: z.number().int().positive().nullable(),
    createdAt: DateTimeSchema,
    updatedAt: DateTimeSchema,
    archivePath: z.string().trim().min(1),
  })),
});

export const RestoreJsonNotebooksSchema = z.object({
  notebooks: z.array(JsonBackupNotebookSchema).min(1).max(100),
});

export const RestoreJsonMemosSchema = z.object({
  memos: z.array(JsonBackupMemoSchema).min(1).max(10),
});

export const JsonBackupAiPromptSchema = z.object({
  id: z.string().trim().min(1).max(200),
  origin: z.enum(["default", "custom"]),
  seedKey: z.enum(AI_ACTIONS.filter((action) => action !== "custom") as [
    Exclude<(typeof AI_ACTIONS)[number], "custom">,
    ...Exclude<(typeof AI_ACTIONS)[number], "custom">[],
  ]).nullable(),
  action: z.enum(AI_ACTIONS),
  parameterKind: z.enum(AI_PROMPT_PARAMETER_KINDS),
  resultMode: z.enum(AI_PROMPT_RESULT_MODES),
  nameCustomized: z.boolean(),
  descriptionCustomized: z.boolean(),
  instructionCustomized: z.boolean(),
  name: z.string().trim().min(1).max(80),
  description: z.string().max(200).nullable(),
  instruction: z.string().trim().min(1).max(2_000),
  createdAt: DateTimeSchema,
  updatedAt: DateTimeSchema,
}).superRefine((prompt, context) => {
  if (prompt.origin === "default" && !prompt.seedKey) {
    context.addIssue({
      code: "custom",
      path: ["seedKey"],
      message: "A default prompt must include a seed key.",
    });
  }
  if (prompt.origin === "default" && prompt.seedKey && prompt.action !== prompt.seedKey) {
    context.addIssue({
      code: "custom",
      path: ["action"],
      message: "A default prompt action must match its seed key.",
    });
  }
  if (prompt.origin === "custom" && (prompt.seedKey !== null || prompt.action !== "custom")) {
    context.addIssue({
      code: "custom",
      path: ["origin"],
      message: "A custom prompt cannot use factory prompt identity.",
    });
  }
});

export const RestoreJsonAiPromptsSchema = z.object({
  prompts: z.array(JsonBackupAiPromptSchema).max(100),
});

export const JsonBackupResourceMetadataSchema = JsonBackupMemoSchema.shape.resources.element;

// Desktop-only IPC metadata. Archive bytes and saved passwords never cross this interface.
export type DesktopBackupConfig = {
  enabled: boolean;
  interval: "daily" | "weekly" | "biweekly" | "monthly";
  retention: 1 | 3 | 5 | 10 | 20;
  directory: string;
  encrypted: boolean;
};
export type DesktopBackupError = { code: string; message?: string; status?: number };
// Optional WebDAV copy of each completed local backup. The password stays in the main process.
export type DesktopOffsiteConfig = { enabled: boolean; url: string; username: string; folder: string };
export type DesktopOffsiteStatus = {
  config: DesktopOffsiteConfig;
  passwordSet: boolean;
  secureStorageAvailable: boolean;
  lastAttemptAt: string | null;
  lastSuccessAt: string | null;
  lastUploaded: { name: string; size: number; uploadedAt: string } | null;
  error: DesktopBackupError | null;
  warning: DesktopBackupError | null;
  task: { name: string; sent: number; total: number } | null;
};
export type DesktopBackupStatus = {
  blocked: boolean;
  config: DesktopBackupConfig;
  backupSetId: string;
  actualDirectory: string;
  passwordSet: boolean;
  secureStorageAvailable: boolean;
  lastCheck: { at: string; result: "running" | "success" | "unchanged" | "failed" | "cancelled" } | null;
  lastAttemptAt: string | null;
  lastSuccessAt: string | null;
  lastRestoreAt: string | null;
  nextDueAt: string | null;
  pendingPublication: { name: string; encrypted: boolean } | null;
  target: { baseUrl: string; accountId: string };
  error: DesktopBackupError | null;
  warning: DesktopBackupError | null;
  importError: DesktopBackupError | null;
  importWarning: DesktopBackupError | null;
  history: Array<{ name: string; directory: string; completedAt: string; size: number; encrypted: boolean }>;
  task: null | { kind: "export" | "import"; phase: "checking-source" | "exporting" | "decrypting" | "checking" | "ready" | "restoring"; completed: number; total: number; manifest?: JsonBackupManifest };
  /** Older desktop builds omit it. */
  offsite?: DesktopOffsiteStatus | null;
};
export type DesktopBackupSelection = { id: string; name: string; encrypted: boolean };
export type DesktopBackupActions = {
  status: { input?: never; output: DesktopBackupStatus | null };
  save: { input: { backupSetId: string; config: DesktopBackupConfig; password?: string }; output: DesktopBackupStatus };
  "choose-directory": { input: { backupSetId: string }; output: string | null };
  run: { input: { backupSetId: string; password?: string; options?: { name: string; encrypted: boolean } }; output: DesktopBackupStatus };
  cancel: { input: { backupSetId: string }; output: DesktopBackupStatus | null };
  "open-folder": { input: { backupSetId: string }; output: boolean };
  "choose-import": { input: { backupSetId: string }; output: DesktopBackupSelection | null };
  "select-history": { input: { backupSetId: string; name: string }; output: DesktopBackupSelection };
  "delete-history": { input: { backupSetId: string; name: string }; output: DesktopBackupStatus };
  "prepare-import": { input: { backupSetId: string; id: string; password?: string }; output: DesktopBackupStatus };
  "confirm-import": { input: { backupSetId: string }; output: DesktopBackupStatus };
  "offsite-save": { input: { backupSetId: string; config: DesktopOffsiteConfig; password?: string }; output: DesktopBackupStatus };
  "offsite-test": { input: { backupSetId: string; config: DesktopOffsiteConfig; password?: string }; output: { ok: true } };
  "offsite-upload": { input: { backupSetId: string }; output: DesktopBackupStatus };
};