takerofnotes/takerofnotes-app
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor + warning for failed decryptions

Browse Source
This commit is contained in:
nicwands
2026-04-02 11:45:46 -04:00
parent a0a5cde33a
commit ad961fd31a
16 changed files with 505 additions and 187 deletions
Download Patch File Download Diff File Expand all files Collapse all files

165
out/main/index.js
View File

@@ -5,6 +5,7 @@ import filesystemPlugin from "@takerofnotes/plugin-filesystem";
import supabasePlugin from "@takerofnotes/plugin-supabase";
import s3Plugin from "@takerofnotes/plugin-s3";
import postgresPlugin from "@takerofnotes/plugin-postgre-sql";
import Ajv from "ajv";
import sodium from "libsodium-wrappers";
import { v4 } from "uuid";
import { Index } from "flexsearch";
@@ -74,13 +75,60 @@ class PluginRegistry {
}));
}
}
const ajv = new Ajv({ allErrors: true, strict: false });
const getDefaultConfig = () => {
return {
activeAdapter: "browser",
theme: "dark"
};
};
const createConfigManager = (storage) => {
const CONFIG_SCHEMA = {
type: "object",
properties: {
activeAdapter: { type: "string" },
theme: { type: "string", enum: ["dark", "light"] },
encryptionKey: { type: "string" },
adapters: { type: "object" }
},
required: ["activeAdapter"],
additionalProperties: true
};
const validateConfig = ajv.compile(CONFIG_SCHEMA);
const convertSchemaToJson = (schemaArray) => {
const properties = {};
const required = [];
for (const field of schemaArray) {
properties[field.key] = { type: "string" };
if (field.required) {
required.push(field.key);
}
}
return {
type: "object",
properties,
required,
additionalProperties: false
};
};
const validateAdapterConfigs = (adapters, pluginManager) => {
if (!adapters || !pluginManager) return { valid: true, errors: [] };
const errors = [];
for (const [adapterId, adapterConfig] of Object.entries(adapters)) {
const plugin = pluginManager.getPlugin(adapterId);
if (!plugin?.configSchema) continue;
const schema = convertSchemaToJson(plugin.configSchema);
const validate = ajv.compile(schema);
const valid = validate(adapterConfig);
if (!valid) {
const adapterErrors = validate.errors.map(
(e) => `${adapterId}${e.instancePath}: ${e.message}`
);
errors.push(...adapterErrors);
}
}
return { valid: errors.length === 0, errors };
};
const createConfigManager = (storage, pluginManager) => {
let config = null;
return {
async loadConfig() {
@@ -96,6 +144,20 @@ const createConfigManager = (storage) => {
return config;
},
async setConfig(newConfig) {
const valid = validateConfig(newConfig);
if (!valid) {
const errors = validateConfig.errors.map((e) => `${e.instancePath || "root"}: ${e.message}`).join("; ");
throw new Error(`Config validation failed: ${errors}`);
}
const adapterValidation = validateAdapterConfigs(
newConfig.adapters,
pluginManager
);
if (!adapterValidation.valid) {
throw new Error(
`Adapter config validation failed: ${adapterValidation.errors.join("; ")}`
);
}
config = newConfig;
await storage.save(newConfig);
},
@@ -111,8 +173,10 @@ class NotesAPI {
}
this.adapter = adapter;
this.notesCache = /* @__PURE__ */ new Map();
this.categories = /* @__PURE__ */ new Set();
this.encryptionKey = encryptionKey;
this._sodiumReady = false;
this._decryptionFailures = [];
this.index = new Index({
tokenize: "forward"
});
@@ -124,11 +188,10 @@ class NotesAPI {
}
}
_hexToUint8Array(hex) {
const bytes = new Uint8Array(hex.length / 2);
for (let i = 0; i < bytes.length; i++) {
bytes[i] = parseInt(hex.substr(i * 2, 2), 16);
}
return bytes;
return Uint8Array.from(
hex.match(/.{1,2}/g),
(byte) => parseInt(byte, 16)
);
}
_concatUint8Arrays(a, b) {
const result = new Uint8Array(a.length + b.length);
@@ -137,19 +200,11 @@ class NotesAPI {
return result;
}
_uint8ArrayToBase64(bytes) {
let binary = "";
for (let i = 0; i < bytes.length; i++) {
binary += String.fromCharCode(bytes[i]);
}
return btoa(binary);
return btoa(String.fromCharCode(...bytes));
}
_base64ToUint8Array(base64) {
const binary = atob(base64);
const bytes = new Uint8Array(binary.length);
for (let i = 0; i < binary.length; i++) {
bytes[i] = binary.charCodeAt(i);
}
return bytes;
return Uint8Array.from(binary, (c) => c.charCodeAt(0));
}
_encrypt(note) {
if (!this.encryptionKey) {
@@ -218,18 +273,28 @@ class NotesAPI {
await this._initSodium();
await this.adapter.init();
this.notesCache.clear();
this.categories.clear();
this._decryptionFailures = [];
const encryptedNotes = await this.adapter.getAll();
for (const encryptedNote of encryptedNotes) {
const noteId = encryptedNote.id || "unknown";
try {
const note = this._decrypt(encryptedNote.data || encryptedNote);
this.notesCache.set(note.id, note);
if (note.category) {
this.categories.add(note.category);
}
const searchText = note.plainText || this._extractPlainText(note.content);
this.index.add(note.id, note.title + "\n" + searchText);
} catch (error) {
console.error("Failed to decrypt note:", error);
this._decryptionFailures.push(noteId);
}
}
}
getDecryptionFailures() {
return [...this._decryptionFailures];
}
_extractPlainText(content) {
if (!content) return "";
if (typeof content === "string") return content;
@@ -241,19 +306,14 @@ class NotesAPI {
return extractText(content);
}
getCategories() {
const categories = /* @__PURE__ */ new Set();
for (const note of this.notesCache.values()) {
if (note.category) {
categories.add(note.category);
}
}
return Array.from(categories).sort();
return Array.from(this.categories).sort();
}
getCategoryNotes(categoryName = null) {
return Array.from(this.notesCache.values()).filter((n) => n.category === categoryName).sort((a, b) => new Date(b.updatedAt) - new Date(a.updatedAt)).map((n) => ({ ...n }));
}
getNote(id) {
const note = this.notesCache.get(id);
console.log(id, this.notesCache);
return note ? { ...note } : null;
}
async createNote(metadata = {}, content = "", plainText = "") {
@@ -273,14 +333,32 @@ class NotesAPI {
data: this._encrypt(note)
};
this.notesCache.set(id, note);
if (note.category) {
this.categories.add(note.category);
}
this.index.add(id, note.title + "\n" + plainText);
await this.adapter.create(encryptedNote);
return note;
}
async deleteNote(id) {
const note = this.notesCache.get(id);
const category = note?.category;
await this.adapter.delete(id);
this.notesCache.delete(id);
this.index.remove(id);
if (category) {
const notesWithCategory = Array.from(
this.notesCache.values()
).filter((n) => n.category === category);
if (notesWithCategory.length === 0) {
this.categories.delete(category);
}
}
if (this._decryptionFailures.includes(id)) {
this._decryptionFailures = this._decryptionFailures.filter(
(id2) => id2 !== id2
);
}
}
async updateNote(id, updates = {}) {
const note = this.notesCache.get(id);
@@ -291,6 +369,7 @@ class NotesAPI {
throw new Error(`Invalid update field: ${key}`);
}
}
const oldCategory = note.category;
const updatedNote = {
...note,
...updates,
@@ -301,6 +380,19 @@ class NotesAPI {
data: this._encrypt(updatedNote)
};
this.notesCache.set(id, updatedNote);
if (updates.category !== void 0) {
if (oldCategory) {
const notesWithOldCategory = Array.from(
this.notesCache.values()
).filter((n) => n.category === oldCategory && n.id !== id);
if (notesWithOldCategory.length === 0) {
this.categories.delete(oldCategory);
}
}
if (updatedNote.category) {
this.categories.add(updatedNote.category);
}
}
const searchText = updatedNote.plainText || this._extractPlainText(updatedNote.content);
this.index.update(id, updatedNote.title + "\n" + searchText);
await this.adapter.update(encryptedNote);
@@ -319,46 +411,45 @@ const generateEncryptionKey = () => {
crypto.getRandomValues(array);
return Array.from(array).map((b) => b.toString(16).padStart(2, "0")).join("");
};
const initPluginManager = (runtime, plugins, config) => {
const initPluginManager = (runtime, plugins) => {
const registry = new PluginRegistry();
for (const plugin of plugins) {
registry.register(plugin);
}
const manager = createPluginManager(registry);
const activeConfig = config.adapters?.[config.activeAdapter] || {};
manager.setActivePlugin(config.activeAdapter, activeConfig);
return manager;
return createPluginManager(registry);
};
const initConfigManager = async (runtime) => {
const initConfigManager = async (runtime, pluginManager) => {
let storage;
{
const { createNodeStorage } = await import("./NodeStorage-B8VFtrTS.js");
const filesystemPlugin2 = (await import("@takerofnotes/plugin-filesystem")).default;
storage = createNodeStorage(filesystemPlugin2);
}
return createConfigManager(storage);
return createConfigManager(storage, pluginManager);
};
const initializeCore = async (runtime, { plugins }) => {
const configManager = await initConfigManager();
const pluginManager = initPluginManager(runtime, plugins);
const configManager = await initConfigManager(runtime, pluginManager);
const config = await configManager.loadConfig();
const pluginManager = initPluginManager(runtime, plugins, config);
const activeConfig = config.adapters?.[config.activeAdapter] || {};
pluginManager.setActivePlugin(config.activeAdapter, activeConfig);
let notesAPI = null;
let initPromise = null;
const getNotesAPI = async () => {
if (notesAPI) return notesAPI;
if (!initPromise) {
initPromise = (async () => {
const config2 = await configManager.loadConfig();
let encryptionKey = config2?.encryptionKey;
const latestConfig = await configManager.loadConfig();
let encryptionKey = latestConfig?.encryptionKey;
if (!encryptionKey) {
encryptionKey = generateEncryptionKey();
await configManager.setConfig({
...config2,
...latestConfig,
encryptionKey
});
}
const pluginId = config2?.activeAdapter || "filesystem";
const adapterConfig = config2?.adapters?.[pluginId] || {};
const pluginId = latestConfig?.activeAdapter || "filesystem";
const adapterConfig = latestConfig?.adapters?.[pluginId] || {};
const adapter = pluginManager.getAdapter(
pluginId,
adapterConfig