AI-native knowledge base & Evernote/Obsidian alternative with instant sync & native MCP. Free on Cloudflare or self-hosted via Docker.
HTML ai-agentcloudflarecloudflare-d1cloudflare-r2cloudflare-workersdockerelectronevernoteevernote-alternativeknowledge-basemcpnote-takingobsidian-alternativeoffline-firstpersonal-knowledge-basepwaself-hostedsqlitetiptapweb-clipper
import { memoLocalSnapshot } from "./local-memo-guard";
import type {
DesktopMemoCreateParams,
DesktopMemoListParams,
DesktopMemoUpdateParams,
DesktopRpcMethod,
DesktopRpcParams,
DesktopRpcResponses,
} from "@edgeever/shared";
import { docToMarkdown, docToText, markdownToDoc, type MemoDetail } from "@edgeever/shared";
import { localizeDefaultMemoTemplate } from "@edgeever/shared/memo-template-seeds";
import type { EdgeEverRepository } from "@/lib/repository";
import { api, getConfiguredDesktopApiBaseUrl } from "@/lib/api";
import { createStagedResourceListItem, mapMarkdownResourceUrls, mapTiptapResourceUrls, toApiResourceUrl, toDesktopResourceUrl } from "@/lib/desktop-resources";
import {
applyStagedResourceUrlRewrites,
collectStagedResourceReferences,
contentReferencesStagedResourceUrl,
repairMemoStagedResourceUrls,
stagedResourceIdFromUrl,
} from "@/lib/staged-resource-repair";
import type { ResourceListItem, ResourceStorageSummary } from "@edgeever/shared";
import { notifySyncQueueDeferred } from "@/lib/sync-events";
const resolveResourceUrls = <T extends { resources: Array<{ url: string }> }>(result: T): T => {
const baseUrl = getConfiguredDesktopApiBaseUrl();
return {
...result,
resources: result.resources.map((resource) => ({ ...resource, url: toDesktopResourceUrl(resource.url.startsWith("/") ? `${baseUrl}${resource.url}` : resource.url) })),
};
};
const toDisplayMemo = (memo: MemoDetail): MemoDetail => ({
...memo,
contentJson: mapTiptapResourceUrls(memo.contentJson, toDesktopResourceUrl),
contentMarkdown: mapMarkdownResourceUrls(memo.contentMarkdown, toDesktopResourceUrl) ?? "",
});
const liveStagedIdsForMemo = async (memoId: string) => {
const staged = await listStagedResources();
return new Set(
staged
.filter((resource) => resource.memoId === memoId)
.map((resource) => stagedResourceIdFromUrl(resource.url))
.filter((id): id is string => Boolean(id)),
);
};
const resourcesForMemo = async (memoId: string) => {
const listed = await request("resource.list", { limit: 500 });
return listed.resources.filter((resource) => resource.memoId === memoId);
};
const rewriteUploadedAliases = async <T extends { contentJson?: unknown; contentMarkdown?: string | null }>(memoId: string, memo: T): Promise<T> => {
const aliases = await window.edgeeverDesktop?.listStagedResourceAliases?.(memoId) ?? [];
if (aliases.length === 0) return memo;
const rewrites = aliases.map((item) => ({
placeholder: `edgeever-staged://${item.id}`,
url: `/api/v1/resources/${encodeURIComponent(item.resourceId)}/blob`,
}));
return {
...memo,
contentJson: applyStagedResourceUrlRewrites(memo.contentJson, rewrites) as T["contentJson"],
contentMarkdown: typeof memo.contentMarkdown === "string"
? applyStagedResourceUrlRewrites(memo.contentMarkdown, rewrites) as string
: memo.contentMarkdown,
};
};
const repairDisplayedMemo = async (memo: MemoDetail): Promise<MemoDetail> => {
if (
!contentReferencesStagedResourceUrl(memo.contentJson)
&& !contentReferencesStagedResourceUrl(memo.contentMarkdown)
) {
return toDisplayMemo(memo);
}
const aliased = await rewriteUploadedAliases(memo.id, memo);
if (!contentReferencesStagedResourceUrl(aliased.contentJson)
&& !contentReferencesStagedResourceUrl(aliased.contentMarkdown)) return toDisplayMemo(aliased);
const [resources, liveStagedIds] = await Promise.all([resourcesForMemo(memo.id), liveStagedIdsForMemo(memo.id)]);
return toDisplayMemo(repairMemoStagedResourceUrls(aliased, resources, liveStagedIds));
};
const listStagedResources = async (): Promise<ResourceListItem[]> => {
const bridge = window.edgeeverDesktop;
if (!bridge?.isAvailable) return [];
const staged = await bridge.listStagedResources();
const now = new Date().toISOString();
return staged.map((item) => createStagedResourceListItem(item, now));
};
const mergeStagedResources = async <T extends { resources: ResourceListItem[]; summary: ResourceStorageSummary }>(result: T): Promise<T> => {
const staged = await listStagedResources();
if (staged.length === 0) return result;
const stagedSummary: ResourceStorageSummary = {
totalCount: staged.length,
totalBytes: staged.reduce((total, resource) => total + resource.byteSize, 0),
imageCount: staged.filter((resource) => resource.kind === "image").length,
attachmentCount: staged.filter((resource) => resource.kind === "attachment").length,
};
return {
...result,
resources: [...staged, ...result.resources],
summary: {
totalCount: result.summary.totalCount + stagedSummary.totalCount,
totalBytes: result.summary.totalBytes + stagedSummary.totalBytes,
imageCount: result.summary.imageCount + stagedSummary.imageCount,
attachmentCount: result.summary.attachmentCount + stagedSummary.attachmentCount,
},
};
};
const request = async <M extends DesktopRpcMethod>(method: M, params: DesktopRpcParams[M]) => {
const bridge = window.edgeeverDesktop;
if (!bridge?.isAvailable) throw new Error("EdgeEver desktop bridge is unavailable");
return bridge.sidecarRequest<DesktopRpcResponses[M]>(method, params);
};
export const cancelPendingDesktopImportMemo = async (memoId: string) => {
const result = await request("memo.delete", { memoId, permanent: true, cancelPendingCreate: true });
window.dispatchEvent(new CustomEvent("edgeever:sync-queue-changed"));
return result;
};
export const createDesktopRepository = (): EdgeEverRepository => ({
listNotebooks: () => request("notebook.list", {}),
createNotebook: (input) => request("notebook.create", input).then((result) => {
window.dispatchEvent(new CustomEvent("edgeever:sync-queue-changed"));
return result;
}),
updateNotebook: (notebookId, input) => request("notebook.update", { notebookId, ...input }).then((result) => {
window.dispatchEvent(new CustomEvent("edgeever:sync-queue-changed"));
return result;
}),
deleteNotebook: (notebookId) => request("notebook.delete", { notebookId }).then((result) => {
window.dispatchEvent(new CustomEvent("edgeever:sync-queue-changed"));
return result;
}),
restoreNotebook: (notebookId) => request("notebook.restore", { notebookId }).then((result) => {
window.dispatchEvent(new CustomEvent("edgeever:sync-queue-changed"));
return result;
}),
listTemplates: async () => {
const local = await request("template.list", {});
const refresh = async () => {
if (typeof navigator !== "undefined" && !navigator.onLine) return;
try {
const remote = await api.listTemplates();
await Promise.all(remote.templates.map((template) => request("template.cache", { template })));
} catch {
// The local snapshot remains the durable fallback for the next open.
}
};
if (local.templates.length > 0) {
void refresh();
return local;
}
if (typeof navigator !== "undefined" && !navigator.onLine) return local;
const remote = await api.listTemplates();
await Promise.all(remote.templates.map((template) => request("template.cache", { template })));
return remote;
},
createTemplate: (input) => request("template.create", input).then((result) => {
window.dispatchEvent(new CustomEvent("edgeever:sync-queue-changed"));
return result;
}),
updateTemplate: (templateId, input) => request("template.update", { templateId, ...input }).then((result) => {
window.dispatchEvent(new CustomEvent("edgeever:sync-queue-changed"));
return result;
}),
deleteTemplate: (templateId) => request("template.delete", { templateId }).then((result) => {
window.dispatchEvent(new CustomEvent("edgeever:sync-queue-changed"));
return result;
}),
useTemplate: async (templateId, notebookId, locale) => {
const templates = await createDesktopRepository().listTemplates();
const stored = templates.templates.find((candidate) => candidate.id === templateId);
if (!stored) throw new Error(`Template not found: ${templateId}`);
const template = locale ? localizeDefaultMemoTemplate(stored, locale) : stored;
return createDesktopRepository().createMemo({ notebookId, title: template.title ?? "", contentMarkdown: template.contentMarkdown, tags: template.tags });
},
uploadMemoResource: async (memoId, file) => {
const result = await api.uploadMemoResource(memoId, file);
await request("resource.cache", { resource: result.resource });
return { resource: { ...result.resource, url: toDesktopResourceUrl(result.resource.url) } };
},
readResource: async (resourceId) => (
await api.getResourceResponse(`/api/v1/resources/${encodeURIComponent(resourceId)}/blob`, { cache: "no-store" })
).blob(),
updateResource: async (resourceId, file, expectedContentHash) => {
const result = await api.updateResourceContent(resourceId, file, expectedContentHash);
await request("resource.delete", { resourceId });
await request("resource.cache", { resource: result.resource });
return { resource: { ...result.resource, url: toDesktopResourceUrl(result.resource.url) } };
},
listResources: async () => {
const local = await request("resource.list", { limit: 500 });
const staged = await listStagedResources();
const localResult = () => mergeStagedResources(resolveResourceUrls(local));
const refresh = async () => {
if (typeof navigator !== "undefined" && !navigator.onLine) return;
try {
const remote = await api.listResources();
await Promise.all(remote.resources.map((resource) => request("resource.cache", { resource })));
} catch {
// Keep the last local resource index available for offline and startup use.
}
};
if (local.resources.length > 0 || staged.length > 0) {
void refresh();
return localResult();
}
if (typeof navigator !== "undefined" && !navigator.onLine) return localResult();
try {
const remote = await api.listResources();
await Promise.all(remote.resources.map((resource) => request("resource.cache", { resource })));
return mergeStagedResources(resolveResourceUrls(remote));
} catch (error) {
if (staged.length > 0) {
return mergeStagedResources({ resources: [], summary: { totalCount: 0, totalBytes: 0, imageCount: 0, attachmentCount: 0 } });
}
throw error;
}
},
renameResource: async (resourceId, filename) => {
const result = await api.renameResource(resourceId, filename);
await request("resource.cache", { resource: result.resource });
return { resource: { ...result.resource, url: toDesktopResourceUrl(result.resource.url) } };
},
deleteResource: async (resourceId) => {
const result = await api.deleteResource(resourceId);
await request("resource.delete", { resourceId });
return result;
},
listTags: () => request("tag.list", {}),
renameTag: (tag, name) => request("tag.rename", { tag, name }).then((result) => {
window.dispatchEvent(new CustomEvent("edgeever:sync-queue-changed"));
return result;
}),
deleteTag: (tag) => request("tag.delete", { tag }).then((result) => {
window.dispatchEvent(new CustomEvent("edgeever:sync-queue-changed"));
return result;
}),
moveMemos: (input) => request("memo.moveBatch", input).then((result) => {
window.dispatchEvent(new CustomEvent("edgeever:sync-queue-changed"));
return result;
}),
deleteMemos: (input) => request("memo.deleteBatch", input).then((result) => {
window.dispatchEvent(new CustomEvent("edgeever:sync-queue-changed"));
return result;
}),
emptyTrash: () => request("memo.emptyTrash", {}).then((result) => {
window.dispatchEvent(new CustomEvent("edgeever:sync-queue-changed"));
return result;
}),
pinMemos: (input) => request("memo.pinBatch", input).then((result) => {
window.dispatchEvent(new CustomEvent("edgeever:sync-queue-changed"));
return result;
}),
mergeMemos: async (input) => {
const result = await request("memo.merge", input);
window.dispatchEvent(new CustomEvent("edgeever:sync-queue-changed"));
return { memo: await repairDisplayedMemo(result.memo) };
},
duplicateMemo: async (memoId, input = {}) => {
if (typeof navigator !== "undefined" && !navigator.onLine) throw new Error("memo_duplicate_offline");
// The server copies the note, so its local edits are synchronized first.
const { syncDesktopData } = await import("@/lib/desktop-sync");
await syncDesktopData();
// The sidecar lists at most 200 outbox items, so a change of this note
// further down the queue cannot be seen. Duplicate only when the whole
// outstanding queue was listed and none of it belongs to this note.
const [status, outbox] = await Promise.all([
request("sync.status", {}),
request("sync.outbox.list", { limit: 200, includeConflicts: true }),
]);
const outstanding = status.pending + status.error + status.conflict;
if (
status.syncing > 0
|| outbox.items.length < outstanding
|| outbox.items.some((item) => item.entityId === memoId)
) {
throw new Error("memo_duplicate_pending_changes");
}
const result = await api.duplicateMemo(memoId, input);
await request("sync.apply", {
changes: [{ entityType: "memo", operation: "upsert", entityId: result.memo.id, memo: result.memo, notebook: null }],
});
return { memo: await repairDisplayedMemo((await request("memo.get", { memoId: result.memo.id, includeDeleted: false })).memo) };
},
listMemos: (params) => {
const rpcParams: DesktopMemoListParams = {
...params,
notebookId: params.notebookIds?.length ? null : (params.notebookId ?? null),
};
return request("memo.list", rpcParams);
},
getMemo: async (memoId, includeDeleted = false) => {
const result = await request("memo.get", { memoId, includeDeleted });
return { memo: await repairDisplayedMemo(result.memo) };
},
createMemo: (input) => {
// The sidecar fallback wraps raw lines as paragraphs; parse Markdown here
// with the same schema used by the editor before persisting a new note.
const contentJson = input.contentJson ?? markdownToDoc(input.contentMarkdown ?? "");
const rpcParams: DesktopMemoCreateParams = {
...input,
contentJson,
contentMarkdown: mapMarkdownResourceUrls(input.contentMarkdown, toApiResourceUrl),
contentText: docToText(contentJson),
};
return request("memo.create", rpcParams).then((result) => {
window.dispatchEvent(new CustomEvent("edgeever:sync-queue-changed"));
return result;
});
},
updateMemo: async (memo: MemoDetail, input, options) => {
const needsStagedRepair = contentReferencesStagedResourceUrl(input.contentJson)
|| contentReferencesStagedResourceUrl(input.contentMarkdown);
const aliasedInput = needsStagedRepair
? await rewriteUploadedAliases(memo.id, { contentJson: input.contentJson, contentMarkdown: input.contentMarkdown })
: input;
const repairedInput = contentReferencesStagedResourceUrl(aliasedInput.contentJson)
|| contentReferencesStagedResourceUrl(aliasedInput.contentMarkdown)
? repairMemoStagedResourceUrls(aliasedInput, ...(await Promise.all([resourcesForMemo(memo.id), liveStagedIdsForMemo(memo.id)])))
: aliasedInput;
if (contentReferencesStagedResourceUrl(repairedInput.contentJson)
|| contentReferencesStagedResourceUrl(repairedInput.contentMarkdown)) {
const live = new Set((await window.edgeeverDesktop?.listStagedResources() ?? []).map((item) => item.id));
const references = collectStagedResourceReferences(repairedInput);
if (references.length === 0 || references.some((reference) => !live.has(reference.stagedId))) {
throw new Error("Memo contains a missing staged resource");
}
}
const portableContentJson = mapTiptapResourceUrls(repairedInput.contentJson ?? input.contentJson, toApiResourceUrl);
const contentMarkdown = repairedInput.contentMarkdown === undefined && input.contentMarkdown === undefined
? docToMarkdown(portableContentJson)
: mapMarkdownResourceUrls(
typeof repairedInput.contentMarkdown === "string" ? repairedInput.contentMarkdown : input.contentMarkdown,
toApiResourceUrl,
);
const rpcParams: DesktopMemoUpdateParams & { contentText: string } = {
memoId: memo.id,
expectedRevision: memo.revision,
expectedContentHash: memo.contentHash,
title: input.title,
contentJson: portableContentJson,
contentMarkdown,
contentText: docToText(portableContentJson),
tags: input.tags,
};
let result;
if (options?.guardLocalSnapshot) {
const snapshot = memoLocalSnapshot(memo);
try {
result = await request("memo.updateGuarded", {
...rpcParams,
expectedLocalSnapshot: { ...snapshot,
contentJson: mapTiptapResourceUrls(snapshot.contentJson, toApiResourceUrl),
contentMarkdown: mapMarkdownResourceUrls(snapshot.contentMarkdown, toApiResourceUrl) ?? snapshot.contentMarkdown,
},
});
} catch (error) {
const message = error instanceof Error ? error.message : String(error);
if (message.includes("NOTE_CONFLICT:")) throw Object.assign(new Error(message), { code: "NOTE_CONFLICT" });
if (message.includes("Unknown sidecar method: memo.updateGuarded")) throw Object.assign(new Error("Upgrade the desktop host before using guarded plugin note edits."), { code: "HOST_UPGRADE_REQUIRED" });
throw error;
}
} else {
result = await request("memo.update", rpcParams);
}
notifySyncQueueDeferred();
return { memo: await repairDisplayedMemo(result.memo), queued: true as const };
},
adoptCloudMemo: async (memoId) => {
const { discardDesktopMemoConflict } = await import("@/lib/desktop-sync");
const memo = await discardDesktopMemoConflict(memoId);
return { memo: await repairDisplayedMemo(memo) };
},
deleteMemo: (memoId, permanent = false) => request("memo.delete", { memoId, permanent }).then((result) => {
window.dispatchEvent(new CustomEvent("edgeever:sync-queue-changed"));
return result;
}),
restoreMemo: async (memoId) => {
const result = await request("memo.restore", { memoId });
window.dispatchEvent(new CustomEvent("edgeever:sync-queue-changed"));
return { ...result, queued: true as const };
},
listMemoRevisions: async (memoId) => {
const local = await request("memo.revisions", { memoId, limit: 100 });
if (typeof navigator !== "undefined" && !navigator.onLine) return local;
try {
const remote = await api.listMemoRevisions(memoId);
await Promise.all(remote.revisions.map((revision) => request("memo.revision.cache", { revision })));
return remote;
} catch (error) {
if (local.revisions.length > 0) return local;
throw error;
}
},
restoreMemoRevision: async (memoId, revisionId) => {
const result = await request("memo.restoreRevision", { memoId, revisionId });
window.dispatchEvent(new CustomEvent("edgeever:sync-queue-changed"));
return { memo: toDisplayMemo(result.memo) };
},
sync: async () => ({ bootstrapped: false, changed: 0 }),
});