orgnote-api 0.17.0 → 0.17.2

package/dist/tools/__tests__/find-note-files-diff.spec.js

@@ -0,0 +1,168 @@
+import { mkdirSync, writeFileSync, utimesSync, readdirSync } from 'fs';
+import { afterEach, beforeEach, test, expect } from 'vitest';
+import { findNoteFilesDiff } from '../find-notes-files-diff';
+import { statSync } from 'fs';
+import { rmSync } from 'fs';
+import { getFileName } from '../get-file-name';
+import { join } from '../join';
+const testFilesFolder = 'src/tools/__tests__/miscellaneous/';
+const nestedFolder = 'nested-folder/';
+const fn = (fileName) => `${testFilesFolder}${fileName}`;
+const fns = (fileName) => `${testFilesFolder}${nestedFolder}${fileName}`;
+function initFiles() {
+    mkdirSync(testFilesFolder.slice(0, -1));
+    mkdirSync(fn(nestedFolder));
+}
+function cleanFiles() {
+    try {
+        rmSync(testFilesFolder, { recursive: true });
+    }
+    catch (e) { }
+}
+function createTestFile(filePath, updated, content) {
+    writeFileSync(filePath, content);
+    const time = updated.getTime() / 1000; // Convert to seconds
+    utimesSync(filePath, time, time);
+}
+beforeEach(() => initFiles());
+afterEach(() => cleanFiles());
+const fileStatToFileInfo = (path, stat) => ({
+    path,
+    name: getFileName(path),
+    type: stat.isFile() ? 'file' : 'directory',
+    size: stat.size,
+    atime: stat.atime.getTime(),
+    mtime: stat.mtime.getTime(),
+    ctime: stat.ctime.getTime(),
+});
+test('Should sync notes files', async () => {
+    const files = [
+        [fn('file-1.org')],
+        [fn('file-2.org')],
+        [fn('file-9.org'), new Date('2024-10-10')],
+        [fns('file-3.org')],
+        [fns('file-4.org'), new Date('2024-08-09')],
+    ];
+    files.forEach(([f, d], i) => createTestFile(f, d ?? new Date('2024-01-01'), `:PROPERTIES:
+:ID: ${i + 1}
+:PROPERTIES:
+
+* Hello world from note:
+- ${f}`));
+    const storedNotesInfo = [
+        {
+            id: '2',
+            filePath: fn('file-1.org').split('/'),
+            updatedAt: new Date('2024-01-01'),
+        },
+        {
+            id: '3',
+            filePath: fns('file-3.org').split('/'),
+            updatedAt: new Date('2024-01-01'),
+        },
+        {
+            id: '9',
+            filePath: fn('file-9.org').split('/'),
+            updatedAt: new Date('2020-01-01'),
+        },
+        {
+            id: '10',
+            filePath: fns('file-10.org').split('/'),
+            updatedAt: new Date('2020-01-01'),
+        },
+    ];
+    const notesFilesDiff = await findNoteFilesDiff({
+        fileInfo: async (path) => {
+            const stats = statSync(path);
+            const fileInfo = fileStatToFileInfo(path, stats);
+            return Promise.resolve(fileInfo);
+        },
+        readDir: async (path) => {
+            const dirents = readdirSync(path, { withFileTypes: true });
+            const fileInfos = dirents.map((dirent) => {
+                const stats = statSync(join(path, dirent.name));
+                const fileInfo = fileStatToFileInfo(join(path, dirent.name), stats);
+                return fileInfo;
+            });
+            return Promise.resolve(fileInfos);
+        },
+        storedNotesInfo,
+        dirPath: testFilesFolder,
+    });
+    expect(notesFilesDiff).toMatchInlineSnapshot(`
+    {
+      "created": [
+        {
+          "filePath": "src/tools/__tests__/miscellaneous/file-2.org",
+        },
+        {
+          "filePath": "src/tools/__tests__/miscellaneous/nested-folder/file-4.org",
+        },
+      ],
+      "deleted": [
+        {
+          "filePath": "src/tools/__tests__/miscellaneous/nested-folder/file-10.org",
+          "id": "10",
+        },
+      ],
+      "updated": [
+        {
+          "filePath": "src/tools/__tests__/miscellaneous/file-9.org",
+        },
+      ],
+    }
+  `);
+});
+test('Should detect no changes when all files match stored info', async () => {
+    const files = [
+        [fn('file-1.org'), new Date('2024-01-01')],
+        [fn('file-2.org'), new Date('2024-01-01')],
+        [fns('file-3.org'), new Date('2024-01-01')],
+    ];
+    files.forEach(([f, d], i) => createTestFile(f, d ?? new Date('2024-01-01'), `:PROPERTIES:
+:ID: ${i + 1}
+:PROPERTIES:
+
+* Note:
+- ${f}`));
+    const storedNotesInfo = [
+        {
+            id: '1',
+            filePath: fn('file-1.org').split('/'),
+            updatedAt: new Date('2024-01-01'),
+        },
+        {
+            id: '2',
+            filePath: fn('file-2.org').split('/'),
+            updatedAt: new Date('2024-01-01'),
+        },
+        {
+            id: '3',
+            filePath: fns('file-3.org').split('/'),
+            updatedAt: new Date('2024-01-01'),
+        },
+    ];
+    const notesFilesDiff = await findNoteFilesDiff({
+        fileInfo: async (path) => {
+            const stats = statSync(path);
+            const fileInfo = fileStatToFileInfo(path, stats);
+            return Promise.resolve(fileInfo);
+        },
+        readDir: async (path) => {
+            const dirents = readdirSync(path, { withFileTypes: true });
+            const fileInfos = dirents.map((dirent) => {
+                const stats = statSync(join(path, dirent.name));
+                const fileInfo = fileStatToFileInfo(join(path, dirent.name), stats);
+                return fileInfo;
+            });
+            return Promise.resolve(fileInfos);
+        },
+        storedNotesInfo,
+        dirPath: testFilesFolder,
+    });
+    expect(notesFilesDiff).toEqual({
+        created: [],
+        updated: [],
+        deleted: [],
+    });
+});

package/dist/tools/__tests__/get-file-name.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tools/__tests__/get-file-name.spec.js

@@ -0,0 +1,14 @@
+import { getFileName, getFileNameWithoutExtension } from '../get-file-name';
+import { test, expect } from 'vitest';
+test('Should return file name from path', () => {
+    expect(getFileName('/some/path/foo.org')).toBe('foo.org');
+});
+test('Should return file name from file name', () => {
+    expect(getFileName('foo.org')).toBe('foo.org');
+});
+test('Should return file name without extension', () => {
+    expect(getFileNameWithoutExtension('foo.org')).toBe('foo');
+});
+test('Should return file name without extension from path', () => {
+    expect(getFileNameWithoutExtension('/some/path/foo.org')).toBe('foo');
+});

package/dist/tools/__tests__/get-string-path.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tools/__tests__/get-string-path.spec.js

@@ -0,0 +1,27 @@
+import { getStringPath } from '../get-string-path';
+import { test, expect } from 'vitest';
+test('should return the same string if path is a string', () => {
+    const path = 'some/path';
+    const result = getStringPath(path);
+    expect(result).toBe('some/path');
+});
+test('should join array elements with "/" if path is an array', () => {
+    const path = ['some', 'path'];
+    const result = getStringPath(path);
+    expect(result).toBe('some/path');
+});
+test('should return an empty string if path is an empty array', () => {
+    const path = [];
+    const result = getStringPath(path);
+    expect(result).toBe('');
+});
+test('should handle array with one element correctly', () => {
+    const path = ['single'];
+    const result = getStringPath(path);
+    expect(result).toBe('single');
+});
+test('should handle array with multiple elements correctly', () => {
+    const path = ['this', 'is', 'a', 'test'];
+    const result = getStringPath(path);
+    expect(result).toBe('this/is/a/test');
+});

package/dist/tools/__tests__/is-gpg-encrypted.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/{tools/__tests__/is-gpg-encrypted.spec.ts → dist/tools/__tests__/is-gpg-encrypted.spec.js}

@@ -1,8 +1,7 @@
 import { expect, test } from 'vitest';
 import { isGpgEncrypted } from '../is-gpg-encrypted';
-
 test('Should return true if the content is gpg encrypted', () => {
-  const content = `-----BEGIN PGP MESSAGE-----
+    const content = `-----BEGIN PGP MESSAGE-----
 
 wcFMA/vryg+TTn0rAQ//TBFRjKmjRQoLhSrgeH+NbsZXbxvo7Ey4k+BQ9XA5
 +CMpXH9uFUxsSaI5+McUSEt32VI17HRpXQDCL9nwaWqWOanMaRe0tXXhtox2
@@ -33,12 +32,9 @@ PX6alTbxGnoHgZ4bG4J1wfpTNPppP1gJeVg67VqOypzdZi+SjofMWnFgRFmD
 yEN8xpFUs7A9xryVZOosp9Sfe3IbBkO99sAQ7jV4EoMYk3/GKA==
 =LjkG
 -----END PGP MESSAGE-----`;
-
-  expect(isGpgEncrypted(content)).toBe(true);
+    expect(isGpgEncrypted(content)).toBe(true);
 });
-
 test('Should return false if the content is not gpg encrypted', () => {
-  const content = `Hello World!`;
-
-  expect(isGpgEncrypted(content)).toBe(false);
+    const content = `Hello World!`;
+    expect(isGpgEncrypted(content)).toBe(false);
 });

package/dist/tools/__tests__/is-org-file.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tools/__tests__/is-org-file.spec.js

@@ -0,0 +1,54 @@
+import { test, expect } from 'vitest';
+import { isOrgFile, isOrgGpgFile } from '../is-org-file';
+test('Should return true for org files', () => {
+    const files = [
+        'myNote.org',
+        'my_note.org',
+        '123.org',
+        'some_long_note#4123$123eqasdasd.org.gpg',
+        'some_long_note#4123$123eqasdasd.org',
+        'note with space.org',
+        'note with space.org.gpg',
+    ];
+    files.forEach((file) => {
+        expect(isOrgFile(file), file).toBe(true);
+    });
+});
+test('Should not return true for non-org files', () => {
+    const files = [
+        'myNote.md',
+        'my_note.md',
+        '123.md',
+        'some_long_note#4123$123eqasdas',
+        'note.org.file',
+        'org',
+        'org.',
+        'text.gpg',
+    ];
+    files.forEach((file) => {
+        expect(isOrgFile(file), file).toBe(false);
+    });
+});
+test('Should return true for org.gpg files', () => {
+    const gpgFiles = [
+        'myNote.org.gpg',
+        'my_note.org.gpg',
+        '123.org.gpg',
+        'org.org.gpg',
+        'gp_org.org.gpg',
+    ];
+    gpgFiles.forEach((file) => {
+        expect(isOrgGpgFile(file), file).toBe(true);
+    });
+});
+test('Should not return true for not .org.gpg files', () => {
+    const notGpgFiles = [
+        'myNote.org',
+        'my_note.org',
+        '123.org',
+        'some_gpg_file.txt',
+    ];
+    notGpgFiles.forEach((file) => {
+        expect(isOrgGpgFile(file), file).toBe(false);
+    });
+});

package/dist/tools/__tests__/join.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tools/__tests__/join.spec.js

@@ -0,0 +1,14 @@
+import { test, expect } from 'vitest';
+import { join } from '../join';
+test('Should join file paths', () => {
+    const samples = [
+        ['dir1', 'subdir2', 'file'],
+        ['dir2/', '/file'],
+        ['/dri3', 'subdir2/', 'file'],
+        ['file'],
+    ];
+    samples.forEach((sample) => {
+        const result = join(...sample);
+        expect(result).toMatchSnapshot();
+    });
+});

package/dist/tools/__tests__/read-org-files-recursively.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tools/__tests__/read-org-files-recursively.spec.js

@@ -0,0 +1,51 @@
+import { describe, it, expect, vi } from 'vitest';
+import { readOrgFilesRecursively } from '../find-notes-files-diff';
+// NOTE: AI generated
+const mockReadDir = vi.fn();
+const mockFileInfo = vi.fn();
+describe('readOrgFilesRecursively', () => {
+    it('should read .org files recursively from a directory', async () => {
+        const mockFileSystem = {
+            fileInfo: mockFileInfo,
+            readDir: mockReadDir,
+            dirPath: '/root',
+        };
+        // Set up fake file system structure
+        mockReadDir.mockImplementation(async (path) => {
+            switch (path) {
+                case '/root':
+                    return [
+                        { name: 'file1.org', type: 'file', size: 100, mtime: Date.now() },
+                        { name: 'subdir', type: 'directory', size: 0, mtime: Date.now() },
+                        { name: 'file2.txt', type: 'file', size: 200, mtime: Date.now() },
+                    ];
+                case '/root/subdir':
+                    return [
+                        { name: 'file3.org', type: 'file', size: 100, mtime: Date.now() },
+                        { name: 'file4.md', type: 'file', size: 150, mtime: Date.now() },
+                    ];
+                default:
+                    return [];
+            }
+        });
+        // Execute the function
+        const orgFiles = await readOrgFilesRecursively(mockFileSystem);
+        // Check results
+        expect(orgFiles).toEqual(['/root/file1.org', '/root/subdir/file3.org']);
+        expect(mockReadDir).toHaveBeenCalledTimes(2);
+    });
+    it('should return an empty array if no .org files are found', async () => {
+        const mockFileSystem = {
+            fileInfo: mockFileInfo,
+            readDir: mockReadDir,
+            dirPath: '/emptyDir',
+        };
+        // Set up fake file system structure with no .org files
+        mockReadDir.mockResolvedValue([]);
+        // Execute the function
+        const orgFiles = await readOrgFilesRecursively(mockFileSystem);
+        // Check results
+        expect(orgFiles).toEqual([]);
+        expect(mockReadDir).toHaveBeenCalledWith('/emptyDir');
+    });
+});

package/dist/tools/extend-notes-files-diff.d.ts

@@ -0,0 +1,3 @@
+import { HandlersSyncNotesRequest } from 'src/remote-api';
+import { NoteChanges, FileSystem } from '../models';
+export declare function extendNotesFilesDiff(changes: NoteChanges, readFile: FileSystem['readFile']): Promise<HandlersSyncNotesRequest>;

package/dist/tools/extend-notes-files-diff.js

@@ -0,0 +1,21 @@
+import { isOrgGpgFile } from './is-org-file';
+export async function extendNotesFilesDiff(changes, readFile) {
+    const upsertedNotesFromLastSync = [
+        ...changes.updated,
+        ...changes.created,
+    ];
+    const notesFromLastSync = [];
+    for (const nc of upsertedNotesFromLastSync) {
+        const encrypted = isOrgGpgFile(nc.filePath);
+    }
+    const noteIdsFromLastSync = new Set(notesFromLastSync.map((n) => n.id));
+    const deletedNotesIdsWithoutRename = changes.deleted.reduce((acc, nc) => {
+        if (!noteIdsFromLastSync.has(nc.id)) {
+            acc.push(nc.id);
+        }
+        return acc;
+    }, []);
+    return {
+        deletedNotesIds: deletedNotesIdsWithoutRename,
+    };
+}

package/dist/tools/find-notes-files-diff.d.ts

@@ -0,0 +1,5 @@
+import { SyncParams, Changes, StoredNoteInfo, NoteChanges, FileScanParams, FileSystem } from 'src/models';
+export declare function findNoteFilesDiff({ fileInfo, readDir, lastSync, storedNotesInfo, dirPath, }: SyncParams): Promise<NoteChanges>;
+export declare function getOrgFilesFromLastSync(filePaths: string[], fileInfo: FileSystem['fileInfo'], lastSync?: Date): Promise<string[]>;
+export declare function readOrgFilesRecursively({ fileInfo, readDir, dirPath, }: FileScanParams): Promise<string[]>;
+export declare function findFilesDiff(filePaths: string[], storedNotesInfo: StoredNoteInfo[], updatedTimeGetter: (filePath: string) => Date): Changes;

package/dist/tools/find-notes-files-diff.js

@@ -0,0 +1,108 @@
+import { getStringPath } from './get-string-path';
+import { isOrgFile } from './is-org-file';
+import { join } from './join';
+export async function findNoteFilesDiff({ fileInfo, readDir, lastSync, storedNotesInfo, dirPath, }) {
+    const orgFilePaths = await readOrgFilesRecursively({
+        fileInfo,
+        readDir,
+        dirPath,
+    });
+    const filesFromLastSync = await getOrgFilesFromLastSync(orgFilePaths, fileInfo, lastSync);
+    const deleted = findDeletedNotes(orgFilePaths, storedNotesInfo);
+    const [created, updated] = await findUpdatedCreatedNotes(fileInfo, filesFromLastSync, storedNotesInfo);
+    return {
+        deleted,
+        created,
+        updated,
+    };
+}
+export async function getOrgFilesFromLastSync(filePaths, fileInfo, lastSync) {
+    if (!lastSync) {
+        return filePaths;
+    }
+    return Promise.all(filePaths.filter(async (filePath) => {
+        const stats = await fileInfo(filePath);
+        return (new Date(stats.mtime) > lastSync || new Date(stats.ctime) > lastSync);
+    }));
+}
+function findDeletedNotes(filePaths, storedNotesInfo) {
+    const uniqueFilePaths = new Set(filePaths);
+    return storedNotesInfo.reduce((acc, storedNote) => {
+        const storedNotePath = getStringPath(storedNote.filePath);
+        if (uniqueFilePaths.has(storedNotePath)) {
+            return acc;
+        }
+        acc.push({
+            filePath: storedNotePath,
+            id: storedNote.id,
+        });
+        return acc;
+    }, []);
+}
+async function findUpdatedCreatedNotes(fileInfo, orgFilePaths, storedNotesInfo) {
+    const created = [];
+    const updated = [];
+    const storedNotesInfoMap = getStoredNotesInfoMap(storedNotesInfo);
+    for (const f of orgFilePaths) {
+        const found = storedNotesInfoMap[f];
+        if (!found) {
+            created.push({ filePath: f });
+            continue;
+        }
+        const fileUpdatedTime = new Date((await fileInfo(f))?.mtime);
+        if (found.updatedAt < fileUpdatedTime) {
+            updated.push({ filePath: f });
+        }
+    }
+    return [created, updated];
+}
+function getStoredNotesInfoMap(storedNotesInfo) {
+    return storedNotesInfo.reduce((acc, n) => {
+        acc[getStringPath(n.filePath)] = n;
+        return acc;
+    }, {});
+}
+export async function readOrgFilesRecursively({ fileInfo, readDir, dirPath, }) {
+    const files = await readDir(dirPath);
+    const collectedPaths = [];
+    const getFullPath = (p) => join(dirPath, p);
+    for (const f of files) {
+        if (f.type === 'directory') {
+            const subDirFiles = await readOrgFilesRecursively({
+                fileInfo,
+                readDir,
+                dirPath: getFullPath(f.name),
+            });
+            collectedPaths.push(...subDirFiles);
+            continue;
+        }
+        if (!isOrgFile(f.name)) {
+            continue;
+        }
+        collectedPaths.push(getFullPath(f.name));
+    }
+    return collectedPaths;
+}
+export function findFilesDiff(filePaths, storedNotesInfo, updatedTimeGetter) {
+    const existingFilePaths = new Set(filePaths);
+    const storedNotesPathSet = new Set(storedNotesInfo.map((n) => getStringPath(n.filePath)));
+    const changedFiles = { deleted: [], created: [], updated: [] };
+    storedNotesInfo.forEach((storedNote) => {
+        const fullPath = getStringPath(storedNote.filePath);
+        if (!existingFilePaths.has(fullPath)) {
+            changedFiles.deleted.push(fullPath);
+            return;
+        }
+        const updatedTime = updatedTimeGetter(fullPath);
+        if (updatedTime > new Date(storedNote.updatedAt)) {
+            changedFiles.updated.push(fullPath);
+        }
+    });
+    filePaths.forEach((filePath) => {
+        if (!storedNotesPathSet.has(filePath)) {
+            changedFiles.created.push(filePath);
+            return;
+        }
+    });
+    return changedFiles;
+}

package/dist/tools/get-file-name.d.ts

@@ -0,0 +1,2 @@
+export declare const getFileName: (path: string) => string;
+export declare const getFileNameWithoutExtension: (path: string) => string;

package/dist/tools/get-file-name.js

@@ -0,0 +1,6 @@
+export const getFileName = (path) => {
+    return path.split('/').pop();
+};
+export const getFileNameWithoutExtension = (path) => {
+    return getFileName(path).split('.').shift();
+};

package/dist/tools/get-string-path.d.ts

@@ -0,0 +1 @@
+export declare function getStringPath(path: string | string[]): string;

package/dist/tools/get-string-path.js

@@ -0,0 +1,6 @@
+export function getStringPath(path) {
+    if (Array.isArray(path)) {
+        return `${path.join('/')}`;
+    }
+    return path;
+}

package/dist/tools/index.d.ts

@@ -0,0 +1,6 @@
+export * from './mock-server';
+export * from './is-gpg-encrypted';
+export * from './is-org-file';
+export * from './get-string-path';
+export * from './find-notes-files-diff';
+export * from './join';

package/dist/tools/index.js

@@ -0,0 +1,6 @@
+export * from './mock-server';
+export * from './is-gpg-encrypted';
+export * from './is-org-file';
+export * from './get-string-path';
+export * from './find-notes-files-diff';
+export * from './join';

package/dist/tools/is-gpg-encrypted.d.ts

@@ -0,0 +1 @@
+export declare function isGpgEncrypted(text: string | Uint8Array): boolean;

package/dist/tools/is-gpg-encrypted.js

@@ -0,0 +1,6 @@
+export function isGpgEncrypted(text) {
+    if (text instanceof Uint8Array) {
+        return true;
+    }
+    return text.startsWith('-----BEGIN PGP MESSAGE-----');
+}

package/dist/tools/is-org-file.d.ts

@@ -0,0 +1,2 @@
+export declare const isOrgFile: (fileName: string) => boolean;
+export declare const isOrgGpgFile: (fileName: string) => boolean;

package/dist/tools/is-org-file.js

@@ -0,0 +1,4 @@
+const orgFileExtenstionRegex = /\.org(\.gpg)?$/;
+export const isOrgFile = (fileName) => orgFileExtenstionRegex.test(fileName);
+const orgGpgFileExtenstionRegex = /\.org\.gpg$/;
+export const isOrgGpgFile = (fileName) => orgGpgFileExtenstionRegex.test(fileName);

package/dist/tools/join.d.ts

@@ -0,0 +1 @@
+export declare function join(...path: string[]): string;

package/dist/tools/join.js

@@ -0,0 +1,3 @@
+export function join(...path) {
+    return path.join('/').replace(/\/+/g, '/').replace(/\/+$/, '');
+}

package/dist/tools/mock-server.d.ts

@@ -0,0 +1 @@
+export declare const mockServer: <T extends (...params: any[]) => any>(fn?: T, defaultValue?: ReturnType<T>) => (...params: Parameters<T>) => ReturnType<T>;

package/dist/tools/mock-server.js

@@ -0,0 +1,12 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+export const mockServer = (fn, defaultValue) => {
+    if (!fn) {
+        return (() => { });
+    }
+    return (...params) => {
+        if (process.env.CLIENT) {
+            return fn(...params);
+        }
+        return defaultValue;
+    };
+};

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "orgnote-api",
-  "version": "0.17.0",
+  "version": "0.17.2",
   "description": "Official API for creating extensions for OrgNote app",
   "type": "module",
-  "main": "./index.ts",
+  "main": "./dist/index.js",
   "scripts": {
     "test": "vitest",
     "build": "npm run clear && tsc --project tsconfig.json",
@@ -17,19 +17,11 @@
     "type": "git",
     "url": "git+https://github.com/artawower/orgnote-api.git"
   },
-  "files": [
-    "index.ts",
-    "api.ts",
-    "files-api.ts",
-    "remote-api/**",
-    "models/**",
-    "encryption/**",
-    "tools/**"
-  ],
+  "files": ["dist/**"],
   "exports": {
-    ".": "./index.ts",
-    "./remote-api": "./remote-api/index.ts",
-    "./encryption": "./encryption/index.ts"
+    ".": "./dist/index.js",
+    "./remote-api": "./dist/remote-api/index.js",
+    "./encryption": "./dist/encryption/index.js"
   },
   "keywords": ["orgnote", "org-mode", "org-roam", "api", "extensions"],
   "author": "darkawower <app.orgnote@gmail.com> (https://org-note.com)",