orgnote-api 0.8.3-beta.1 → 0.8.3-beta.2

package/encryption/__tests__/note-encryption.spec.ts

@@ -0,0 +1,261 @@
+import { expect, test } from 'vitest';
+import { decryptNote, encryptNote } from '../note-encryption';
+import { Note } from '../../models';
+import {
+  armoredPublicKey,
+  armoredPrivateKey,
+  privateKeyPassphrase,
+} from './encryption-keys';
+
+test('Should encrypt note content via password', async () => {
+  const content = `#+ID: qweqwe
+
+#+TITLE: Hello worlld
+
+* Hello?`;
+
+  const note: Note = {
+    id: 'id',
+    encrypted: 'gpgPassword',
+    meta: {
+      title: 'My note title',
+      images: [],
+      published: false,
+      description: 'Awesome description',
+    },
+    content,
+    author: {
+      id: '1',
+      name: 'John Doe',
+      email: 'test@mail.com',
+    },
+  };
+
+  const encryptedNote = await encryptNote(note, {
+    type: 'gpgPassword',
+    password: '123',
+  });
+
+  expect(encryptedNote.content.startsWith('-----BEGIN PGP MESSAGE-----')).toBe(
+    true
+  );
+  delete encryptedNote.content;
+  expect(encryptedNote).toMatchSnapshot();
+});
+
+test('Should decrypt note content via password', async () => {
+  const note: Note = {
+    id: 'id',
+    encrypted: 'gpgPassword',
+    meta: {
+      title: 'My note title',
+      images: [],
+      published: false,
+      description: 'Awesome description',
+    },
+    content: `-----BEGIN PGP MESSAGE-----
+
+wy4ECQMI/CCaKMJEqy/gyROJeRgW9I738dDFBltFlxIjhxrN7nQ6gkX4GgX6
+zt3v0mABvaBJA7corlU8su21TpPApOs/+DMWpVlbI3Zer7QfQK1fSBoSTbCR
+2k3g68Afayke2nLkDNkH62tdOPiTkx7bSlp1zL4uU440IM1g6dC72JkmtoTJ
+5Bjlwt4ZhxFsh+c=
+=csID
+-----END PGP MESSAGE-----`,
+  };
+
+  const decryptedNote = await decryptNote(note, {
+    type: 'gpgPassword',
+    password: '123',
+  });
+
+  expect(decryptedNote).toMatchSnapshot();
+});
+
+test('Should encrypt note via keys', async () => {
+  const content = `#+ID: qweqwe
+#+TITLE: Hello worlld
+
+* Hello?`;
+
+  const note: Note = {
+    id: 'id',
+    encrypted: 'gpgKeys',
+    meta: {
+      title: 'My note title for encryption via keys',
+      images: [],
+      published: false,
+      description: 'Awesome description',
+    },
+    content,
+    author: {
+      id: '1',
+      name: 'John Doe',
+      email: 'test@mail.com',
+    },
+  };
+
+  const encryptedNote = await encryptNote(note, {
+    type: 'gpgKeys',
+    publicKey: armoredPublicKey,
+    privateKey: armoredPrivateKey,
+    privateKeyPassphrase,
+  });
+
+  expect(encryptedNote.content.startsWith('-----BEGIN PGP MESSAGE-----')).toBe(
+    true
+  );
+  delete encryptedNote.content;
+  expect(encryptedNote).toMatchSnapshot();
+});
+
+test('Should decrypt note via provided keys', async () => {
+  const note: Note = {
+    id: 'id',
+    encrypted: 'gpgKeys',
+    meta: {
+      title: 'My note title for decryption via keys',
+      images: [],
+      published: false,
+      description: 'Awesome description',
+    },
+    content: `-----BEGIN PGP MESSAGE-----
+
+wcFMA/vryg+TTn0rAQ//TBFRjKmjRQoLhSrgeH+NbsZXbxvo7Ey4k+BQ9XA5
++CMpXH9uFUxsSaI5+McUSEt32VI17HRpXQDCL9nwaWqWOanMaRe0tXXhtox2
+gfe2f/6zsge9ux+mXF2BG4z+V5T8XIOrfzxosVprdJHZHM3x7cW5USQ0t2i2
+FiOUWxSZO1899J3yICpMvhDXvTLVZuKpSNQho5PyXSeZa83eN+uYkhgt9lsk
+0KW88Nr435S6n6mVw/zpitXIgEKpkqh46mhG+1W3aC0lYx6j9lHm3bjtdb4r
+2mtZbWKwfdBggEy8qEeiUeslvKd6uWtEccomzFgJkaqWVGknLmrBdHfztRIV
+fbZhxHz+J3GFOIgXf/5+fv+zg0nTazgz1mDUfnTHw3+qcAyEJ0ADdyg9EZc+
+bKbK0GwzMDPQeM+cCRDWUTiIa1ruyEETiwMdhWUDztF8XxY2o8jXPerZ0NhG
+R8l+SvAdYQQXPfxEh9lA3thkyz/Vp72pW46lUeJHGSq/fS6KIdLHLP9Z2e1J
+aCFpNMgyAN+BaXwnbLZfz6k5hV8awbRScSWQLEg69D9b287SFDPOYW7OZikn
+CKXL7xyQ5LrWJZN9Z/UPGjy+PdEw1SBhyluW6DQ+Sz1j4K8USTLqY89EInDl
+G7AxHGujR9UkUGyUvvc71XW7jEOogiDgn1ZMoj9Y58LSweUB8vfkY3VF84Fy
+zGVvLFWnFbtnWuoQC4OOXv1F6ETdmEsSMEMWKzRLDGPyqNX7FhG3cejlEuiK
+EsT5oQhz00RECmnR8mJkGmJhzWmmeoQvaucFqhTOZjvYl9ivuEMBZ2jtkdHn
+R6UNcNZRpCbfnl7YoikqbGBgqDFYydFGHXKHDpYhcQYWJsMDUayzUiPtzmaE
+tgfTgNNqgPxkLnWA99KYNU8DH+FwgaYBuw9dwdqwcjxSbZjHhCFGUfsqM+ik
+O9gcoAwVO1usODlESU7OWuSF2tIv5DBG5rhlSyxBp4d4aWmaumTswAdojy2O
+sM70ETbg0mC8niW9lNsgJp55oFmlksvzjUIit5rBEr55rtPcJSgakPpR2yvd
+Q4XjybUmV0IdONMhk/OlqaBPtnA0RG+qTcm7oP1qH/m5zRA0ZplVQ5ylkQwr
+LwGq5JQpJkgxxgLIrUbbtzYBShXSr5c1XXR0LIRiNgtb6s1s4mt+fbyExdJF
++ceuu+/xYrW/YTuEJpHxLiZ+aNPW5g5Y7Hbqu3hp3UL/kD44cc8JjZh18spX
+p/ncojDhF2r2vhR+CndYcMkpGMV+t1pGKC8wlcFc7lb9GJASnqMGvhQmvIaG
+gO/x7UjuTZSBW+kITHHZJDqYryKUv1j0CkHxIn9tWsYOpa1giOFtXX5v0AAM
+AJR/s/beLlqwCsUdYnw1TkP/0u0ZK3RPio1nJ7S6ckPfsM7DqCWD8ILD8Cdr
+cuzQrWaE30t5PXx53xBPO+6t5wKfDL35WHWG1Irmvz9UuT7tDS3IzwtF4ijF
+PX6alTbxGnoHgZ4bG4J1wfpTNPppP1gJeVg67VqOypzdZi+SjofMWnFgRFmD
+yEN8xpFUs7A9xryVZOosp9Sfe3IbBkO99sAQ7jV4EoMYk3/GKA==
+=LjkG
+-----END PGP MESSAGE-----`,
+  };
+
+  const decryptedNote = await decryptNote(note, {
+    type: 'gpgKeys',
+    publicKey: armoredPublicKey,
+    privateKey: armoredPrivateKey,
+    privateKeyPassphrase,
+  });
+
+  expect(decryptedNote).toMatchSnapshot();
+});
+
+test('Should not encrypt public note', async () => {
+  const content = `#+ID: qweqwe
+#+TITLE: Hello worlld
+
+* Hello?`;
+
+  const note: Note = {
+    id: 'id',
+    encrypted: 'gpgPassword',
+    meta: {
+      title: 'My note title',
+      images: [],
+      published: true,
+      description: 'Awesome description',
+    },
+    content,
+    author: {
+      id: '1',
+      name: 'John Doe',
+      email: 'test@mail.com',
+    },
+  };
+
+  const encryptedNote = await encryptNote(note, {
+    type: 'gpgPassword',
+    password: '123',
+  });
+
+  expect(encryptedNote.content.startsWith('-----BEGIN PGP MESSAGE-----')).toBe(
+    false
+  );
+  expect(encryptedNote).toMatchSnapshot();
+});
+
+test('Should encrypt note with empty encrypted property', async () => {
+  const content = `#+ID: qweqwe
+#+TITLE: Hello worlld
+
+* Hello?`;
+
+  const note: Note = {
+    id: 'id',
+    meta: {
+      title: 'My note title',
+      images: [],
+      published: false,
+      description: 'Awesome description',
+    },
+    content,
+    author: {
+      id: '1',
+      name: 'John Doe',
+      email: 'test@mail.com',
+    },
+  };
+
+  const encryptedNote = await encryptNote(note, {
+    type: 'gpgPassword',
+    password: '123',
+  });
+
+  expect(encryptedNote.content.startsWith('-----BEGIN PGP MESSAGE-----')).toBe(
+    true
+  );
+
+  delete encryptedNote.content;
+  expect(encryptedNote).toMatchSnapshot();
+});
+
+test('Should not decrypt note without provided encrypted type', async () => {
+  const content = `#+ID: qweqwe
+#+TITLE: Hello worlld
+
+* Hello?`;
+  const note: Note = {
+    id: 'id',
+    meta: {
+      title: 'My note title',
+      images: [],
+      published: false,
+      description: 'Awesome description',
+    },
+    encrypted: undefined,
+    content,
+    author: {
+      id: '1',
+      name: 'John Doe',
+      email: 'test@mail.com',
+    },
+  };
+
+  const decryptedNote = await decryptNote(note, {
+    type: 'gpgPassword',
+    password: '123',
+  });
+
+  expect(decryptedNote).toMatchSnapshot();
+});

package/encryption/encryption.ts

@@ -0,0 +1,172 @@
+import {
+  createMessage,
+  decrypt,
+  decryptKey,
+  encrypt,
+  readKey,
+  readMessage,
+  readPrivateKey,
+} from 'openpgp';
+
+export class IncorrectOrMissingPrivateKeyPasswordError extends Error {}
+export class ImpossibleToDecryptWithProvidedKeysError extends Error {}
+export class IncorrectEncryptionPasswordError extends Error {}
+export class NoKeysProvidedError extends Error {}
+export class NoPasswordProvidedError extends Error {}
+
+const noPrivateKeyPassphraseProvidedErrorMsg =
+  'Error: Signing key is not decrypted.';
+const incorrectPrivateKeyPassphraseErrorMsg =
+  'Error decrypting private key: Incorrect key passphrase';
+const decryptionKeyIsNotDecryptedErrorMsg =
+  'Error decrypting message: Decryption key is not decrypted.';
+const corruptedPrivateKeyErrorMsg = 'Misformed armored text';
+
+const decriptionFailedErrorMsg =
+  'Error decrypting message: Session key decryption failed.';
+const incorrectEncryptionPasswordErrorMsg =
+  'Error decrypting message: Modification detected.';
+
+const noSymmetricallyEncryptedSessionKeyErrorMsg =
+  'Error decrypting message: No symmetrically encrypted session key packet found.';
+
+const armoredTextNotTypePrivateKeyErrorMsg =
+  'Armored text not of type private key';
+
+const notPrivateKeyErrprMsg =
+  'Error decrypting message: No public key encrypted session key packet found.';
+
+export const encryptViaKeys = withCustomErrors(_encryptViaKeys);
+export const encryptViaPassword = withCustomErrors(_encryptViaPassword);
+export const decryptViaPassword = withCustomErrors(_decryptViaPassword);
+export const decryptViaKeys = withCustomErrors(_decryptViaKeys);
+
+async function _encryptViaPassword(
+  text: string,
+  password: string
+): Promise<string> {
+  const message = await createMessage({
+    text,
+  });
+
+  const encryptedMessage = await encrypt({
+    message,
+    format: 'armored',
+    passwords: [password],
+  });
+
+  return encryptedMessage.toString();
+}
+
+async function _encryptViaKeys(
+  text: string,
+  armoredPublicKey: string,
+  armoredPrivateKey: string,
+  privateKeyPassphrase?: string
+): Promise<string> {
+  const publicKey = await readKey({ armoredKey: armoredPublicKey });
+
+  const message = await createMessage({
+    text,
+  });
+
+  const encryptedPrivateKey = await readPrivateKey({
+    armoredKey: armoredPrivateKey,
+  });
+
+  const privateKey = privateKeyPassphrase
+    ? await decryptKey({
+        privateKey: encryptedPrivateKey,
+        passphrase: privateKeyPassphrase,
+      })
+    : encryptedPrivateKey;
+
+  const encryptedMessage = await encrypt({
+    message,
+    format: 'armored',
+    encryptionKeys: publicKey,
+    signingKeys: privateKey,
+  });
+
+  return encryptedMessage.toString();
+}
+
+async function _decryptViaPassword(
+  data: string,
+  password: string
+): Promise<string> {
+  const message = await readMessage({ armoredMessage: data });
+
+  const { data: decryptedText } = await decrypt({
+    message,
+    passwords: password,
+  });
+
+  return decryptedText.toString();
+}
+
+async function _decryptViaKeys(
+  data: string,
+  armoredPrivateKey: string,
+  privateKeyPassword?: string
+): Promise<string> {
+  const encryptedPrivateKey = await readPrivateKey({
+    armoredKey: armoredPrivateKey,
+  });
+
+  const privateKey = privateKeyPassword
+    ? await decryptKey({
+        privateKey: encryptedPrivateKey,
+        passphrase: privateKeyPassword,
+      })
+    : encryptedPrivateKey;
+
+  const message = await readMessage({ armoredMessage: data });
+
+  const { data: decryptedText } = await decrypt({
+    message,
+    decryptionKeys: privateKey,
+  });
+
+  return decryptedText.toString();
+}
+
+function withCustomErrors<P extends unknown[], T>(
+  fn: (...args: P) => Promise<T | never>
+) {
+  return async (...args: P): Promise<T> => {
+    try {
+      return await fn(...args);
+    } catch (e: unknown) {
+      if (!(e instanceof Error)) {
+        throw e;
+      }
+      if (
+        [
+          noPrivateKeyPassphraseProvidedErrorMsg,
+          incorrectPrivateKeyPassphraseErrorMsg,
+          corruptedPrivateKeyErrorMsg,
+          decryptionKeyIsNotDecryptedErrorMsg,
+          armoredTextNotTypePrivateKeyErrorMsg,
+        ].includes(e.message)
+      ) {
+        throw new IncorrectOrMissingPrivateKeyPasswordError(e.message);
+      }
+      if (e.message === decriptionFailedErrorMsg) {
+        throw new ImpossibleToDecryptWithProvidedKeysError(e.message);
+      }
+      if (e.message === incorrectEncryptionPasswordErrorMsg) {
+        throw new IncorrectEncryptionPasswordError();
+      }
+      if (e.message === noSymmetricallyEncryptedSessionKeyErrorMsg) {
+        throw new NoKeysProvidedError();
+      }
+
+      if (e.message === notPrivateKeyErrprMsg) {
+        throw new NoPasswordProvidedError();
+      }
+
+      throw e;
+    }
+  };
+}

package/encryption/index.ts

@@ -0,0 +1,2 @@
+export * from './note-encryption';
+export * from './encryption';

package/encryption/note-encryption.ts

@@ -0,0 +1,133 @@
+import { ModelsPublicNote, ModelsPublicNoteEncryptedEnum } from '../remote-api';
+
+import {
+  decryptViaKeys,
+  decryptViaPassword,
+  encryptViaKeys,
+  encryptViaPassword,
+} from './encryption';
+import { OrgNoteEncryption } from '../models/encryption';
+import { parse, withMetaInfo } from 'org-mode-ast';
+
+export type NoteEncryptedType = `${ModelsPublicNote['encrypted']}`;
+export interface AbstractEncryptedNote {
+  content: string;
+  encrypted?: NoteEncryptedType;
+  meta: {
+    [key: string]: any;
+    published?: boolean;
+  };
+}
+export async function encryptNote<T extends AbstractEncryptedNote>(
+  note: T,
+  encryptionParams: OrgNoteEncryption
+): Promise<T> {
+  if (
+    !encryptionParams.type ||
+    encryptionParams.type === ModelsPublicNoteEncryptedEnum.Disabled ||
+    note.meta.published
+  ) {
+    return note;
+  }
+
+  note.meta = { id: note.meta.id, published: note.meta.published };
+
+  if (encryptionParams.type === ModelsPublicNoteEncryptedEnum.GpgKeys) {
+    return await encryptNoteViaKeys(
+      note,
+      encryptionParams.publicKey,
+      encryptionParams.privateKey,
+      encryptionParams.privateKeyPassphrase
+    );
+  }
+  return await encryptNoteViaPassword(note, encryptionParams.password);
+}
+export async function encryptNoteViaPassword<T extends AbstractEncryptedNote>(
+  note: T,
+  password: string
+): Promise<T> {
+  const content = await encryptViaPassword(note.content, password);
+  return {
+    ...note,
+    content,
+    encrypted: ModelsPublicNoteEncryptedEnum.GpgPassword,
+  };
+}
+
+export async function encryptNoteViaKeys<T extends AbstractEncryptedNote>(
+  note: T,
+  publicKey: string,
+  privateKey: string,
+  privateKeyPassphrase?: string
+): Promise<T> {
+  const content = await encryptViaKeys(
+    note.content,
+    publicKey,
+    privateKey,
+    privateKeyPassphrase
+  );
+
+  return {
+    ...note,
+    content,
+    encrypted: ModelsPublicNoteEncryptedEnum.GpgKeys,
+  };
+}
+
+export async function decryptNote<T extends AbstractEncryptedNote>(
+  note: T,
+  encryptionParams: OrgNoteEncryption
+): Promise<T> {
+  if (
+    note.meta.published ||
+    !note.encrypted ||
+    !encryptionParams.type ||
+    encryptionParams.type === ModelsPublicNoteEncryptedEnum.Disabled
+  ) {
+    return note;
+  }
+  const decryptedNote =
+    encryptionParams.type === ModelsPublicNoteEncryptedEnum.GpgKeys
+      ? await decryptNoteViaKeys(
+          note,
+          encryptionParams.privateKey,
+          encryptionParams.privateKeyPassphrase
+        )
+      : await decryptNoteViaPassword(note, encryptionParams.password);
+
+  const parsed = withMetaInfo(parse(decryptedNote.content));
+
+  return {
+    ...decryptedNote,
+    meta: { ...decryptedNote.meta, published: parsed.meta.published },
+  };
+}
+
+export async function decryptNoteViaPassword<T extends AbstractEncryptedNote>(
+  note: T,
+  password: string
+): Promise<T> {
+  const content = await decryptViaPassword(note.content, password);
+  return {
+    ...note,
+    content,
+    encrypted: ModelsPublicNoteEncryptedEnum.GpgPassword,
+  };
+}
+
+export async function decryptNoteViaKeys<T extends AbstractEncryptedNote>(
+  note: T,
+  privateKey: string,
+  privateKeyPassphrase?: string
+): Promise<T> {
+  const content = await decryptViaKeys(
+    note.content,
+    privateKey,
+    privateKeyPassphrase
+  );
+  return {
+    ...note,
+    content,
+    encrypted: ModelsPublicNoteEncryptedEnum.GpgKeys,
+  };
+}

package/index.ts

@@ -0,0 +1,5 @@
+export * from './api';
+export * from './models';
+import type * as ast from 'org-mode-ast';
+export * from './encryption';
+export { ast };

package/models/command.ts

@@ -0,0 +1,44 @@
+import { DefaultCommands } from './default-commands';
+
+export const DEFAULT_KEYBINDING_GROUP = 'default';
+
+export type CommandGroup =
+  | 'settings'
+  | 'editor'
+  | 'global'
+  | 'note-detail'
+  | 'completion'
+  | string;
+
+export interface CommandHandlerParams<T = any> {
+  event?: KeyboardEvent;
+  data?: T;
+  [key: string]: unknown;
+}
+
+export interface CommandPreview {
+  description?: string;
+  command?: DefaultCommands | string;
+  title?: string | (() => string);
+  icon?: string | (() => string);
+}
+
+export interface CommandMeta<T = any> extends Partial<CommandPreview> {
+  // TODO: add support for multiple key sequences
+  keySequence?: string | string[];
+  /* Where is this command available, default value is global */
+  group?: CommandGroup;
+  allowOnInput?: boolean;
+  ignorePrompt?: boolean;
+  /* When command is system command, it will not be shown for users */
+  system?: boolean;
+  available?: () => boolean;
+  context?: {
+    [key: string]: T;
+  };
+}
+
+export interface Command<T = any> extends CommandMeta<T> {
+  /* arguments depend on the current scope */
+  handler: (params?: CommandHandlerParams) => unknown | Promise<unknown>;
+}

package/models/completion.ts

@@ -0,0 +1,30 @@
+export interface CompletionCandidate<T = unknown> {
+  icon?: string | (() => string);
+  group?: string;
+  title?: string | (() => string);
+  description?: string;
+  command: string;
+  data: T;
+  /* Command handler could be used instead of command string */
+  commandHandler?: (data: T) => void;
+}
+
+export interface CompletionSearchResult<T = unknown> {
+  total?: number;
+  result: CompletionCandidate<T>[];
+}
+
+export type CandidateGetterFn<T = unknown> = (
+  filter: string,
+  limit?: number,
+  offset?: number
+) => CompletionSearchResult<T> | Promise<CompletionSearchResult<T>>;
+
+export interface CompletionConfigs<T = unknown> {
+  searchAutocompletions?: string[];
+  itemsGetter: CandidateGetterFn<T>;
+  placeholder?: string;
+  itemHeight?: string;
+  searchText?: string;
+  onClicked?: (candidate: CompletionCandidate<T>) => void;
+}

package/models/default-commands.ts

@@ -0,0 +1,40 @@
+/*
+ * This are default commands. It's not a complete list
+ * Some of the commands are dynamically generated or
+ * can be added by user extensions.
+ */
+export enum DefaultCommands {
+  // Global commands
+  REPORT_BUG = 'report bug',
+  OPEN_DEBUG_INFO = 'open debug info',
+  SHOW_LOGS = 'show logs',
+  TOGGLE_SIDEBAR = 'toggle sidebar',
+  TOGGLE_FILE_MANAGER = 'toggle file manager',
+  CREATE_NOTE = 'create note',
+  PROJECT_INFO = 'project info',
+
+  // Completion commands
+  SEARCH = 'search',
+  TOGGLE_COMMANDS = 'toggle commands',
+  RESTORE_COMPLETION = 'restore last completion',
+  EXIT_COMMAND_EXECUTOR = 'exit command executor',
+  NEXT_CANDIDATE = 'next candidate',
+  PREV_CANDIDATE = 'previous candidate',
+  EXECUTE_CANDIDATE = 'execute candidate',
+
+  // Settings
+  SETTINGS = 'settings',
+  RESET_THEME = 'reset theme',
+  TOGGLE_DARK_MODE = 'toggle dark mode',
+  TOGGLE_DEBUG_MODE = 'toggle debug mode',
+  SELECT_THEME = 'select theme',
+
+  // Routing
+  OPEN_MY_NOTES = 'my notes',
+  OPEN_DASHBOARD = 'dashboard',
+  OPEN_PUBLIC_NOTE_LIST = 'public note list',
+  OPEN_NOTE_EDITOR = 'edit mode',
+  OPEN_NOTE_VIEWER = 'view mode',
+  OPEN_GRAPH = 'graph',
+  OPEN_EXTENSIONS = 'extensions',
+}