389 lines
12 KiB
JavaScript
389 lines
12 KiB
JavaScript
import "dotenv/config";
|
|
import { electronApp, optimizer, is } from "@electron-toolkit/utils";
|
|
import { app, ipcMain, BrowserWindow, shell } from "electron";
|
|
import filesystemPlugin from "@takerofnotes/plugin-filesystem";
|
|
import supabasePlugin from "@takerofnotes/plugin-supabase";
|
|
import fs from "fs/promises";
|
|
import path, { join } from "path";
|
|
import { Index } from "flexsearch";
|
|
import crypto from "crypto";
|
|
import sodium from "libsodium-wrappers";
|
|
import __cjs_mod__ from "node:module";
|
|
const __filename = import.meta.filename;
|
|
const __dirname = import.meta.dirname;
|
|
const require2 = __cjs_mod__.createRequire(import.meta.url);
|
|
class PluginRegistry {
|
|
constructor() {
|
|
this.plugins = /* @__PURE__ */ new Map();
|
|
}
|
|
register(plugin) {
|
|
if (!plugin.id) {
|
|
throw new Error("Plugin must have an id");
|
|
}
|
|
this.plugins.set(plugin.id, plugin);
|
|
}
|
|
get(id) {
|
|
return this.plugins.get(id);
|
|
}
|
|
list() {
|
|
return Array.from(this.plugins.values());
|
|
}
|
|
}
|
|
const USER_DATA_STRING = "__DEFAULT_USER_DATA__";
|
|
class PluginConfig {
|
|
constructor(defaultPlugin) {
|
|
this.defaultPlugin = defaultPlugin;
|
|
this.configPath = path.join(app.getPath("userData"), "config.json");
|
|
}
|
|
// Helper to replace placeholders with dynamic values, recursively
|
|
_resolveDefaults(config) {
|
|
if (Array.isArray(config)) {
|
|
return config.map((item) => this._resolveDefaults(item));
|
|
} else if (config && typeof config === "object") {
|
|
const resolved = {};
|
|
for (const [key, value] of Object.entries(config)) {
|
|
resolved[key] = this._resolveDefaults(value);
|
|
}
|
|
return resolved;
|
|
} else if (typeof config === "string" && config.includes(USER_DATA_STRING)) {
|
|
return config.replace(USER_DATA_STRING, app.getPath("userData"));
|
|
} else {
|
|
return config;
|
|
}
|
|
}
|
|
async load() {
|
|
let parsed;
|
|
try {
|
|
const raw = await fs.readFile(this.configPath, "utf8");
|
|
parsed = JSON.parse(raw);
|
|
} catch (err) {
|
|
parsed = null;
|
|
}
|
|
if (!parsed || !parsed.activeAdapter) {
|
|
const defaultConfig = {};
|
|
for (const field of this.defaultPlugin.configSchema) {
|
|
defaultConfig[field.key] = field.default ?? null;
|
|
}
|
|
parsed = {
|
|
activeAdapter: this.defaultPlugin.id,
|
|
adapterConfig: defaultConfig
|
|
};
|
|
await this.write(parsed);
|
|
} else {
|
|
parsed.adapterConfig = this._resolveDefaults(parsed.adapterConfig);
|
|
}
|
|
return parsed;
|
|
}
|
|
async write(configObject) {
|
|
const dir = path.dirname(this.configPath);
|
|
await fs.mkdir(dir, { recursive: true });
|
|
const resolvedConfig = {
|
|
...configObject,
|
|
adapterConfig: this._resolveDefaults(configObject.adapterConfig)
|
|
};
|
|
await fs.writeFile(
|
|
this.configPath,
|
|
JSON.stringify(resolvedConfig, null, 2),
|
|
"utf8"
|
|
);
|
|
}
|
|
}
|
|
class NotesAPI {
|
|
constructor(adapter, encryptionKey = null) {
|
|
if (!adapter) {
|
|
throw new Error("NotesAPI requires a storage adapter");
|
|
}
|
|
this.adapter = adapter;
|
|
this.notesCache = /* @__PURE__ */ new Map();
|
|
this.encryptionKey = encryptionKey || process.env.NOTES_ENCRYPTION_KEY;
|
|
this._sodiumReady = false;
|
|
this.index = new Index({
|
|
tokenize: "forward"
|
|
});
|
|
}
|
|
async _initSodium() {
|
|
if (!this._sodiumReady) {
|
|
await sodium.ready;
|
|
this._sodiumReady = true;
|
|
}
|
|
}
|
|
_encrypt(note) {
|
|
if (!this.encryptionKey) {
|
|
throw new Error("Encryption key not set");
|
|
}
|
|
const key = Buffer.from(this.encryptionKey, "hex");
|
|
if (key.length !== 32) {
|
|
throw new Error(
|
|
"Encryption key must be 64 hex characters (32 bytes)"
|
|
);
|
|
}
|
|
const nonce = sodium.randombytes_buf(sodium.crypto_secretbox_NONCEBYTES);
|
|
const message = JSON.stringify(note);
|
|
const ciphertext = sodium.crypto_secretbox_easy(
|
|
Buffer.from(message),
|
|
nonce,
|
|
key
|
|
);
|
|
const combined = Buffer.concat([nonce, ciphertext]);
|
|
return combined.toString("base64");
|
|
}
|
|
_decrypt(encryptedData) {
|
|
if (!this.encryptionKey) {
|
|
throw new Error("Encryption key not set");
|
|
}
|
|
const key = Buffer.from(this.encryptionKey, "hex");
|
|
if (key.length !== 32) {
|
|
throw new Error(
|
|
"Encryption key must be 64 hex characters (32 bytes)"
|
|
);
|
|
}
|
|
let combined;
|
|
try {
|
|
combined = Buffer.from(encryptedData, "base64");
|
|
} catch (e) {
|
|
throw new Error("Invalid encrypted data: not valid base64");
|
|
}
|
|
if (combined.length < sodium.crypto_secretbox_NONCEBYTES + sodium.crypto_secretbox_MACBYTES) {
|
|
throw new Error("Invalid encrypted data: too short");
|
|
}
|
|
const nonce = combined.slice(0, sodium.crypto_secretbox_NONCEBYTES);
|
|
const ciphertext = combined.slice(sodium.crypto_secretbox_NONCEBYTES);
|
|
let decrypted;
|
|
try {
|
|
decrypted = sodium.crypto_secretbox_open_easy(
|
|
ciphertext,
|
|
nonce,
|
|
key
|
|
);
|
|
} catch (e) {
|
|
throw new Error("Decryption failed: wrong key or corrupted data");
|
|
}
|
|
if (!decrypted) {
|
|
throw new Error("Decryption failed: no data returned");
|
|
}
|
|
const decryptedStr = Buffer.from(decrypted).toString("utf8");
|
|
try {
|
|
return JSON.parse(decryptedStr);
|
|
} catch (e) {
|
|
throw new Error(
|
|
`Decryption succeeded but invalid JSON: ${decryptedStr}`
|
|
);
|
|
}
|
|
}
|
|
async init() {
|
|
await this._initSodium();
|
|
await this.adapter.init();
|
|
const encryptedNotes = await this.adapter.getAll();
|
|
for (const encryptedNote of encryptedNotes) {
|
|
try {
|
|
const note = this._decrypt(encryptedNote.data || encryptedNote);
|
|
this.notesCache.set(note.id, note);
|
|
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);
|
|
}
|
|
}
|
|
}
|
|
_extractPlainText(content) {
|
|
if (!content) return "";
|
|
if (typeof content === "string") return content;
|
|
const extractText = (node) => {
|
|
if (typeof node === "string") return node;
|
|
if (!node || !node.content) return "";
|
|
return node.content.map(extractText).join(" ");
|
|
};
|
|
return extractText(content);
|
|
}
|
|
/* -----------------------
|
|
Public API
|
|
------------------------*/
|
|
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();
|
|
}
|
|
getCategoryNotes(categoryName) {
|
|
return Array.from(this.notesCache.values()).filter((n) => n.category === categoryName).sort((a, b) => new Date(b.updatedAt) - new Date(a.updatedAt));
|
|
}
|
|
getNote(id) {
|
|
return this.notesCache.get(id) ?? null;
|
|
}
|
|
async createNote(metadata = {}, content = "", plainText = "") {
|
|
const id = crypto.randomUUID();
|
|
const now = (/* @__PURE__ */ new Date()).toISOString();
|
|
const note = {
|
|
id,
|
|
title: metadata.title || "Untitled",
|
|
category: metadata.category || null,
|
|
createdAt: now,
|
|
updatedAt: now,
|
|
content,
|
|
plainText
|
|
};
|
|
const encryptedNote = {
|
|
id: note.id,
|
|
data: this._encrypt(note)
|
|
};
|
|
this.notesCache.set(id, note);
|
|
this.index.add(id, note.title + "\n" + plainText);
|
|
await this.adapter.create(encryptedNote);
|
|
return note;
|
|
}
|
|
async deleteNote(id) {
|
|
await this.adapter.delete(id);
|
|
this.notesCache.delete(id);
|
|
this.index.remove(id);
|
|
}
|
|
async updateNote(id, content, plainText = "") {
|
|
const note = this.notesCache.get(id);
|
|
if (!note) throw new Error("Note not found");
|
|
note.content = content;
|
|
note.plainText = plainText;
|
|
note.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
|
|
const encryptedNote = {
|
|
id: note.id,
|
|
data: this._encrypt(note)
|
|
};
|
|
this.index.update(id, note.title + "\n" + plainText);
|
|
await this.adapter.update(encryptedNote);
|
|
return note;
|
|
}
|
|
async updateNoteMetadata(id, updates = {}) {
|
|
const note = this.notesCache.get(id);
|
|
if (!note) throw new Error("Note not found");
|
|
const allowedFields = ["title", "category"];
|
|
for (const key of Object.keys(updates)) {
|
|
if (!allowedFields.includes(key)) {
|
|
throw new Error(`Invalid metadata field: ${key}`);
|
|
}
|
|
}
|
|
if (updates.title !== void 0) {
|
|
note.title = updates.title;
|
|
}
|
|
if (updates.category !== void 0) {
|
|
note.category = updates.category;
|
|
}
|
|
note.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
|
|
const encryptedNote = {
|
|
id: note.id,
|
|
data: this._encrypt(note)
|
|
};
|
|
this.index.update(
|
|
id,
|
|
note.title + "\n" + (note.plainText || this._extractPlainText(note.content))
|
|
);
|
|
await this.adapter.update(encryptedNote);
|
|
return note;
|
|
}
|
|
search(query) {
|
|
const ids = this.index.search(query, {
|
|
limit: 50,
|
|
suggest: true
|
|
});
|
|
return ids.map((id) => this.notesCache.get(id));
|
|
}
|
|
}
|
|
const preloadPath = join(__dirname, "../preload/index.mjs");
|
|
const rendererPath = join(__dirname, "../renderer/index.html");
|
|
function createWindow() {
|
|
const mainWindow = new BrowserWindow({
|
|
width: 354,
|
|
height: 549,
|
|
show: false,
|
|
autoHideMenuBar: true,
|
|
webPreferences: {
|
|
preload: preloadPath,
|
|
sandbox: false
|
|
}
|
|
});
|
|
mainWindow.on("ready-to-show", () => {
|
|
mainWindow.show();
|
|
});
|
|
mainWindow.webContents.setWindowOpenHandler((details) => {
|
|
shell.openExternal(details.url);
|
|
return { action: "deny" };
|
|
});
|
|
if (is.dev && process.env["ELECTRON_RENDERER_URL"]) {
|
|
mainWindow.loadURL(process.env["ELECTRON_RENDERER_URL"]);
|
|
} else {
|
|
mainWindow.loadFile(rendererPath);
|
|
}
|
|
}
|
|
function createNoteWindow(noteId) {
|
|
const noteWindow = new BrowserWindow({
|
|
width: 354,
|
|
height: 549,
|
|
autoHideMenuBar: true,
|
|
webPreferences: {
|
|
preload: preloadPath,
|
|
contextIsolation: true,
|
|
nodeIntegration: false,
|
|
sandbox: false
|
|
}
|
|
});
|
|
if (is.dev && process.env["ELECTRON_RENDERER_URL"]) {
|
|
noteWindow.loadURL(
|
|
`${process.env["ELECTRON_RENDERER_URL"]}/#/note/${noteId}`
|
|
);
|
|
} else {
|
|
noteWindow.loadFile(rendererPath, {
|
|
hash: `/note/${noteId}`
|
|
});
|
|
}
|
|
}
|
|
app.whenReady().then(async () => {
|
|
ipcMain.on("open-note-window", (_, noteId) => {
|
|
createNoteWindow(noteId);
|
|
});
|
|
const registry = new PluginRegistry();
|
|
registry.register(filesystemPlugin);
|
|
registry.register(supabasePlugin);
|
|
const config = await new PluginConfig(filesystemPlugin).load();
|
|
const plugin = registry.get(config.activeAdapter);
|
|
const adapter = plugin.createAdapter(config.adapterConfig);
|
|
const notesAPI = new NotesAPI(
|
|
adapter,
|
|
"729a0d21d783654c68f1a0123e2a0e986350de536b5324f1f35876ea12ffeaf5"
|
|
);
|
|
await notesAPI.init();
|
|
const broadcastNoteChange = (event, data) => {
|
|
BrowserWindow.getAllWindows().forEach((win) => {
|
|
win.webContents.send(event, data);
|
|
});
|
|
};
|
|
ipcMain.handle("notesAPI:call", async (_, method, args) => {
|
|
if (!notesAPI[method]) {
|
|
throw new Error("Invalid method");
|
|
}
|
|
const result = await notesAPI[method](...args);
|
|
if (method === "createNote") {
|
|
broadcastNoteChange("note-created", result);
|
|
} else if (method === "updateNote") {
|
|
broadcastNoteChange("note-updated", result);
|
|
} else if (method === "updateNoteMetadata") {
|
|
broadcastNoteChange("note-updated", result);
|
|
} else if (method === "deleteNote") {
|
|
broadcastNoteChange("note-deleted", { id: args[0] });
|
|
}
|
|
return result;
|
|
});
|
|
electronApp.setAppUserModelId("com.electron");
|
|
app.on("browser-window-created", (_, window) => {
|
|
optimizer.watchWindowShortcuts(window);
|
|
});
|
|
createWindow();
|
|
app.on("activate", function() {
|
|
if (BrowserWindow.getAllWindows().length === 0) createWindow();
|
|
});
|
|
});
|
|
app.on("window-all-closed", () => {
|
|
if (process.platform !== "darwin") {
|
|
app.quit();
|
|
}
|
|
});
|