orgnote-api 0.41.13 → 0.41.15

package/api.d.ts

@@ -1,4 +1,4 @@
-import { InlineEmbeddedWidget, MultilineEmbeddedWidget, OrgLineClass, SyncStoreDefinition, BufferViewerStoreDefinition, CommandsStoreDefinition, CommandsGroupStoreDefinition, ModalStoreDefinition, SettingsStoreDefinition, SettingsUiStoreDefinition, MultipleUploadParams, UploadParams, CompletionStoreDefinition, PaneStoreDefinition, LayoutStoreDefinition, FileManagerStoreDefinition, UseScreenDetection, UseKeyboardState, NotificationsStoreDefinition, BufferStoreDefinition, BufferProviderStoreDefinition, Repositories, LogStoreDefinition, UseSystemInfo, ContextMenuStoreDefinition, QueueStoreDefinition, FileGuardStoreDefinition, FileWatcherStoreDefinition, BuildOrgNoteUrl, AuthStoreDefinition, FileSearchStoreDefinition, FileMetaStoreDefinition, FontStoreDefinition, EmbeddedBufferStoreDefinition } from './models/index.js';
+import { InlineEmbeddedWidget, MultilineEmbeddedWidget, OrgLineClass, SyncStoreDefinition, BufferViewerStoreDefinition, CommandsStoreDefinition, CommandsGroupStoreDefinition, ModalStoreDefinition, SettingsStoreDefinition, SettingsUiStoreDefinition, MultipleUploadParams, UploadParams, CompletionStoreDefinition, PaneStoreDefinition, LayoutStoreDefinition, FileManagerStoreDefinition, UseScreenDetection, UseKeyboardState, NotificationsStoreDefinition, BufferStoreDefinition, BufferProviderStoreDefinition, Repositories, LogStoreDefinition, UseSystemInfo, ContextMenuStoreDefinition, QueueStoreDefinition, FileGuardStoreDefinition, FileWatcherStoreDefinition, BuildOrgNoteUrl, AuthStoreDefinition, FileSearchStoreDefinition, FileMetaStoreDefinition, FontStoreDefinition, EmbeddedBufferStoreDefinition, UseFileContent } from './models/index.js';
 import { WebSocketClient } from './websocket/client.js';
 import { WidgetType } from './models/widget-type.js';
 import { NodeType } from 'org-mode-ast';
@@ -76,6 +76,7 @@ export interface OrgNoteApi {
         useFileSearch: FileSearchStoreDefinition;
         useFileMeta: FileMetaStoreDefinition;
         useEmbeddedBuffer: EmbeddedBufferStoreDefinition;
+        useFileContent: UseFileContent;
         app: App;
     };
     utils: {

package/constants/i18n-keys.d.ts

@@ -37,7 +37,7 @@ export declare enum i18n {
     GPG_PRIVATE_KEY = "GPG private key",
     ENCRYPT_EXISTING_NOTES = "encrypt existing notes",
     ENCRYPTION_KEYS_GEN_WARNING = "be careful, the old encryption keys will be lost. Third-party clients will need to update encryption keys.",
-    ENCRYPT_AND_SYNC = "encrypt and sync existing notes",
+    ENCRYPTED_NOTES_KEY_CHANGE_WARNING = "you have encrypted notes. Changing encryption keys will make them unreadable unless you re-encrypt them manually. Continue?",
     SYNC_FILES = "sync files",
     SYNC_FILES_DESCRIPTION = "synchronize all local files with the remote server",
     GENERATE_GPG_KEYS = "generate new GPG keys",
@@ -163,7 +163,9 @@ export declare enum i18n {
     TOC_NO_HEADLINES_FOUND = "no headlines found",
     PICK_NOTE_TO_LINK = "pick note to link",
     UNTITLED = "untitled",
-    NO_SELECTED_NOTE = "no selected note"
+    NO_SELECTED_NOTE = "no selected note",
+    GPG_EMAIL_REQUIRED = "gpg email required",
+    GPG_EMAIL_INVALID = "gpg email invalid"
 }
 export declare const I18N: {
     REPORT_BUG: DefaultCommands.REPORT_BUG;
@@ -226,6 +228,9 @@ export declare const I18N: {
     RELOAD_FILES: DefaultCommands.RELOAD_FILES;
     ENCRYPT_NOTE: DefaultCommands.ENCRYPT_NOTE;
     DECRYPT_NOTE: DefaultCommands.DECRYPT_NOTE;
+    UPLOAD_PRIVATE_KEY: DefaultCommands.UPLOAD_PRIVATE_KEY;
+    UPLOAD_PUBLIC_KEY: DefaultCommands.UPLOAD_PUBLIC_KEY;
+    GENERATE_GPG_KEYS: DefaultCommands.GENERATE_GPG_KEYS;
     MAXIMIZE_FILE_MANAGER: DefaultCommands.MAXIMIZE_FILE_MANAGER;
     CREATE_FOLDER: DefaultCommands.CREATE_FOLDER;
     CREATE_FILE: DefaultCommands.CREATE_FILE;
@@ -318,9 +323,8 @@ export declare const I18N: {
     GPG_PRIVATE_KEY: i18n.GPG_PRIVATE_KEY;
     ENCRYPT_EXISTING_NOTES: i18n.ENCRYPT_EXISTING_NOTES;
     ENCRYPTION_KEYS_GEN_WARNING: i18n.ENCRYPTION_KEYS_GEN_WARNING;
-    ENCRYPT_AND_SYNC: i18n.ENCRYPT_AND_SYNC;
+    ENCRYPTED_NOTES_KEY_CHANGE_WARNING: i18n.ENCRYPTED_NOTES_KEY_CHANGE_WARNING;
     SYNC_FILES_DESCRIPTION: i18n.SYNC_FILES_DESCRIPTION;
-    GENERATE_GPG_KEYS: i18n.GENERATE_GPG_KEYS;
     UPLOAD: i18n.UPLOAD;
     AVAILABLE_FOR_SUBSCRIPTION: i18n.AVAILABLE_FOR_SUBSCRIPTION;
     SUCCESSFULLY_SUBSCRIBED: i18n.SUCCESSFULLY_SUBSCRIBED;
@@ -439,5 +443,7 @@ export declare const I18N: {
     PICK_NOTE_TO_LINK: i18n.PICK_NOTE_TO_LINK;
     UNTITLED: i18n.UNTITLED;
     NO_SELECTED_NOTE: i18n.NO_SELECTED_NOTE;
+    GPG_EMAIL_REQUIRED: i18n.GPG_EMAIL_REQUIRED;
+    GPG_EMAIL_INVALID: i18n.GPG_EMAIL_INVALID;
 };
 export type I18N = i18n | DefaultCommands;

package/constants/i18n-keys.js

@@ -38,7 +38,7 @@ export var i18n;
     i18n["GPG_PRIVATE_KEY"] = "GPG private key";
     i18n["ENCRYPT_EXISTING_NOTES"] = "encrypt existing notes";
     i18n["ENCRYPTION_KEYS_GEN_WARNING"] = "be careful, the old encryption keys will be lost. Third-party clients will need to update encryption keys.";
-    i18n["ENCRYPT_AND_SYNC"] = "encrypt and sync existing notes";
+    i18n["ENCRYPTED_NOTES_KEY_CHANGE_WARNING"] = "you have encrypted notes. Changing encryption keys will make them unreadable unless you re-encrypt them manually. Continue?";
     i18n["SYNC_FILES"] = "sync files";
     i18n["SYNC_FILES_DESCRIPTION"] = "synchronize all local files with the remote server";
     i18n["GENERATE_GPG_KEYS"] = "generate new GPG keys";
@@ -174,6 +174,9 @@ export var i18n;
     i18n["PICK_NOTE_TO_LINK"] = "pick note to link";
     i18n["UNTITLED"] = "untitled";
     i18n["NO_SELECTED_NOTE"] = "no selected note";
+    // GPG
+    i18n["GPG_EMAIL_REQUIRED"] = "gpg email required";
+    i18n["GPG_EMAIL_INVALID"] = "gpg email invalid";
 })(i18n || (i18n = {}));
 export const I18N = {
     ...i18n,

package/encryption/encryption.d.ts

@@ -21,6 +21,16 @@ export declare const encryptViaKeys: <T extends WithEncryptionContent<OrgNoteGpg
 export declare const encryptViaPassword: <T extends WithEncryptionContent<OrgNotePasswordEncryption>>(args_0: T) => Promise<T["format"] extends "binary" ? Uint8Array<ArrayBufferLike> : string>;
 export declare const decryptViaPassword: <T extends Omit<WithDecryptionContent<OrgNotePasswordEncryption>, "type">>(args_0: T) => Promise<T["format"] extends "binary" ? Uint8Array<ArrayBufferLike> : string>;
 export declare const decryptViaKeys: <T extends Omit<WithDecryptionContent<OrgNoteGpgEncryption>, "type">>(args_0: T) => Promise<T["format"] extends "binary" ? Uint8Array<ArrayBufferLike> : string>;
+export interface GenerateGpgKeysParams {
+    username: string;
+    email: string;
+    passphrase?: string;
+}
+export interface GeneratedGpgKeys {
+    privateKey: string;
+    publicKey: string;
+}
+export declare const generateGpgKeys: (params: GenerateGpgKeysParams) => Promise<GeneratedGpgKeys>;
 export declare const encrypt: <T extends WithEncryptionContent<OrgNoteEncryption>>(encryptionParams: T) => Promise<T["format"] extends "binary" ? Uint8Array : string>;
 export declare const decrypt: <T extends WithDecryptionContent<OrgNoteEncryption>>(decryptionParams: T) => Promise<T["format"] extends "binary" ? Uint8Array : string>;
 export declare function _encryptViaKeys<T extends WithEncryptionContent<OrgNoteGpgEncryption>>({ content, publicKey: armoredPublicKey, privateKey: armoredPrivateKey, privateKeyPassphrase, format, }: T): Promise<T['format'] extends 'binary' ? Uint8Array : string>;

package/encryption/encryption.js

@@ -1,49 +1,63 @@
-import { createMessage, decrypt as _decrypt, decryptKey, encrypt as _encrypt, readKey, readMessage, readPrivateKey, } from 'openpgp';
+import { createMessage, decrypt as _decrypt, decryptKey, encrypt as _encrypt, generateKey, readKey, readMessage, readPrivateKey, } from 'openpgp';
 import { EncryptionType, } from "../models/encryption.js";
 import { armor as _armor, unarmor as _unarmor, enums } from 'openpgp';
 export class IncorrectOrMissingPrivateKeyPasswordError extends Error {
     constructor(message) {
-        super(message);
+        super(message ?? 'Private key passphrase is missing or incorrect. Please check your encryption settings.');
         this.name = 'IncorrectOrMissingPrivateKeyPasswordError';
     }
 }
 export class ImpossibleToDecryptWithProvidedKeysError extends Error {
     constructor(message) {
-        super(message);
+        super(message ?? 'Decryption failed. The provided keys cannot decrypt this file.');
         this.name = 'ImpossibleToDecryptWithProvidedKeysError';
     }
 }
 export class IncorrectEncryptionPasswordError extends Error {
     constructor(message) {
-        super(message);
+        super(message ?? 'Incorrect encryption password.');
         this.name = 'IncorrectEncryptionPasswordError';
     }
 }
 export class NoKeysProvidedError extends Error {
     constructor(message) {
-        super(message);
+        super(message ?? 'No encryption keys provided. Please configure keys in Settings → Encryption.');
         this.name = 'NoKeysProvidedError';
     }
 }
 export class NoPasswordProvidedError extends Error {
     constructor(message) {
-        super(message);
+        super(message ?? 'No encryption password provided. Please configure password in Settings → Encryption.');
         this.name = 'NoPasswordProvidedError';
     }
 }
-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.';
+const PRIVATE_KEY_NOT_DECRYPTED_PATTERNS = [
+    'Signing key is not decrypted',
+    'Incorrect key passphrase',
+    'Misformed armored text',
+    'Decryption key is not decrypted',
+    'Armored text not of type private key',
+];
+const DECRYPTION_FAILED_PATTERN = 'Session key decryption failed';
+const INCORRECT_PASSWORD_PATTERN = 'Modification detected';
+const NO_SYMMETRIC_KEY_PATTERN = 'No symmetrically encrypted session key packet found';
+const NO_PUBLIC_KEY_PATTERN = '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);
+export const generateGpgKeys = async (params) => {
+    const { privateKey, publicKey } = await generateKey({
+        type: 'curve25519',
+        userIDs: [{ name: params.username, email: params.email }],
+        passphrase: params.passphrase,
+        format: 'armored',
+    });
+    return {
+        privateKey,
+        publicKey,
+    };
+};
 export const encrypt = async (encryptionParams) => {
     if (!encryptionParams.type ||
         encryptionParams.type === EncryptionType.Disabled) {
@@ -137,6 +151,7 @@ async function _decryptViaKeys({ privateKey: armoredPrivateKey, privateKeyPassph
     });
     return decryptedText;
 }
+const messageContains = (message, pattern) => message.includes(pattern);
 function withCustomErrors(fn) {
     return async (...args) => {
         try {
@@ -146,25 +161,20 @@ function withCustomErrors(fn) {
             if (!(e instanceof Error)) {
                 throw e;
             }
-            if ([
-                noPrivateKeyPassphraseProvidedErrorMsg,
-                incorrectPrivateKeyPassphraseErrorMsg,
-                corruptedPrivateKeyErrorMsg,
-                decryptionKeyIsNotDecryptedErrorMsg,
-                armoredTextNotTypePrivateKeyErrorMsg,
-            ].includes(e.message)) {
-                throw new IncorrectOrMissingPrivateKeyPasswordError(e.message);
+            const msg = e.message;
+            if (PRIVATE_KEY_NOT_DECRYPTED_PATTERNS.some((p) => messageContains(msg, p))) {
+                throw new IncorrectOrMissingPrivateKeyPasswordError();
             }
-            if (e.message === decriptionFailedErrorMsg) {
-                throw new ImpossibleToDecryptWithProvidedKeysError(e.message);
+            if (messageContains(msg, DECRYPTION_FAILED_PATTERN)) {
+                throw new ImpossibleToDecryptWithProvidedKeysError();
             }
-            if (e.message === incorrectEncryptionPasswordErrorMsg) {
+            if (messageContains(msg, INCORRECT_PASSWORD_PATTERN)) {
                 throw new IncorrectEncryptionPasswordError();
             }
-            if (e.message === noSymmetricallyEncryptedSessionKeyErrorMsg) {
+            if (messageContains(msg, NO_SYMMETRIC_KEY_PATTERN)) {
                 throw new NoKeysProvidedError();
             }
-            if (e.message === notPrivateKeyErrprMsg) {
+            if (messageContains(msg, NO_PUBLIC_KEY_PATTERN)) {
                 throw new NoPasswordProvidedError();
             }
             throw e;

package/models/default-commands.d.ts

@@ -59,6 +59,9 @@ export declare enum DefaultCommands {
     RELOAD_FILES = "reload files",
     ENCRYPT_NOTE = "encrypt note",
     DECRYPT_NOTE = "decrypt note",
+    UPLOAD_PRIVATE_KEY = "upload private key",
+    UPLOAD_PUBLIC_KEY = "upload public key",
+    GENERATE_GPG_KEYS = "generate gpg keys",
     MAXIMIZE_FILE_MANAGER = "maximize file manager",
     CREATE_FOLDER = "create folder",
     CREATE_FILE = "create file",

package/models/default-commands.js

@@ -72,6 +72,10 @@ export var DefaultCommands;
     DefaultCommands["RELOAD_FILES"] = "reload files";
     DefaultCommands["ENCRYPT_NOTE"] = "encrypt note";
     DefaultCommands["DECRYPT_NOTE"] = "decrypt note";
+    // Encryption key management
+    DefaultCommands["UPLOAD_PRIVATE_KEY"] = "upload private key";
+    DefaultCommands["UPLOAD_PUBLIC_KEY"] = "upload public key";
+    DefaultCommands["GENERATE_GPG_KEYS"] = "generate gpg keys";
     // File manager
     DefaultCommands["MAXIMIZE_FILE_MANAGER"] = "maximize file manager";
     DefaultCommands["CREATE_FOLDER"] = "create folder";

package/models/encryption.d.ts

@@ -1,4 +1,5 @@
 import { InferOutput } from 'valibot';
+import { DefaultCommands } from './default-commands.js';
 export declare const EncryptionType: {
     readonly GpgKeys: "gpgKeys";
     readonly GpgPassword: "gpgPassword";
@@ -17,16 +18,22 @@ declare const OrgNoteGpgEncryptionSchema: import("valibot").ObjectSchema<{
     readonly privateKey: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MetadataAction<string, {
         readonly textarea: true;
         readonly upload: true;
+        readonly command: DefaultCommands.UPLOAD_PRIVATE_KEY;
     }>]>;
     readonly publicKey: import("valibot").SchemaWithPipe<readonly [import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>, import("valibot").MetadataAction<string, {
         readonly textarea: true;
         readonly upload: true;
+        readonly command: DefaultCommands.UPLOAD_PUBLIC_KEY;
+    }>]>;
+    readonly privateKeyPassphrase: import("valibot").SchemaWithPipe<readonly [import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>, import("valibot").MetadataAction<string, {
+        readonly password: true;
     }>]>;
-    readonly privateKeyPassphrase: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
 }, undefined>;
 declare const OrgNotePasswordEncryptionSchema: import("valibot").ObjectSchema<{
     readonly type: import("valibot").LiteralSchema<"gpgPassword", undefined>;
-    readonly password: import("valibot").StringSchema<undefined>;
+    readonly password: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MetadataAction<string, {
+        readonly password: true;
+    }>]>;
 }, undefined>;
 export declare const OrgNoteEncryptionSchema: import("valibot").IntersectSchema<[import("valibot").ObjectSchema<{
     readonly encryptFilesByDefault: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
@@ -35,15 +42,21 @@ export declare const OrgNoteEncryptionSchema: import("valibot").IntersectSchema<
     readonly privateKey: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MetadataAction<string, {
         readonly textarea: true;
         readonly upload: true;
+        readonly command: DefaultCommands.UPLOAD_PRIVATE_KEY;
     }>]>;
     readonly publicKey: import("valibot").SchemaWithPipe<readonly [import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>, import("valibot").MetadataAction<string, {
         readonly textarea: true;
         readonly upload: true;
+        readonly command: DefaultCommands.UPLOAD_PUBLIC_KEY;
+    }>]>;
+    readonly privateKeyPassphrase: import("valibot").SchemaWithPipe<readonly [import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>, import("valibot").MetadataAction<string, {
+        readonly password: true;
     }>]>;
-    readonly privateKeyPassphrase: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
 }, undefined>, import("valibot").ObjectSchema<{
     readonly type: import("valibot").LiteralSchema<"gpgPassword", undefined>;
-    readonly password: import("valibot").StringSchema<undefined>;
+    readonly password: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MetadataAction<string, {
+        readonly password: true;
+    }>]>;
 }, undefined>, import("valibot").ObjectSchema<{
     readonly type: import("valibot").LiteralSchema<"disabled", undefined>;
 }, undefined>], undefined>, import("valibot").MetadataAction<{

package/models/encryption.js

@@ -1,5 +1,6 @@
 import { boolean, metadata } from 'valibot';
 import { object, string, union, optional, literal, intersect, pipe, } from 'valibot';
+import { DefaultCommands } from './default-commands.js';
 export const EncryptionType = {
     GpgKeys: 'gpgKeys',
     GpgPassword: 'gpgPassword',
@@ -7,13 +8,21 @@ export const EncryptionType = {
 };
 const OrgNoteGpgEncryptionSchema = object({
     type: literal(EncryptionType.GpgKeys),
-    privateKey: pipe(string(), metadata({ textarea: true, upload: true })),
-    publicKey: pipe(optional(string()), metadata({ textarea: true, upload: true })),
-    privateKeyPassphrase: optional(string()),
+    privateKey: pipe(string(), metadata({
+        textarea: true,
+        upload: true,
+        command: DefaultCommands.UPLOAD_PRIVATE_KEY,
+    })),
+    publicKey: pipe(optional(string()), metadata({
+        textarea: true,
+        upload: true,
+        command: DefaultCommands.UPLOAD_PUBLIC_KEY,
+    })),
+    privateKeyPassphrase: pipe(optional(string()), metadata({ password: true })),
 });
 const OrgNotePasswordEncryptionSchema = object({
     type: literal(EncryptionType.GpgPassword),
-    password: string(),
+    password: pipe(string(), metadata({ password: true })),
 });
 const OrgNoteDisabledEncryptionSchema = object({
     type: literal(EncryptionType.Disabled),

package/models/file-content.d.ts

@@ -0,0 +1,5 @@
+export interface FileContent {
+    read(path: string): Promise<Uint8Array>;
+    write(path: string, content: Uint8Array): Promise<void>;
+}
+export type UseFileContent = () => FileContent;

package/models/file-content.js

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

package/models/index.d.ts

@@ -85,6 +85,7 @@ export * from './font-store.js';
 export * from './file-search-store.js';
 export * from './file-meta-store.js';
 export * from './embedded-buffer-store.js';
+export * from './file-content.js';
 export * from './style-variant.js';
 export * from './style-size.js';
 export * from './repositories.js';

package/models/index.js

@@ -87,6 +87,7 @@ export * from "./font-store.js";
 export * from "./file-search-store.js";
 export * from "./file-meta-store.js";
 export * from "./embedded-buffer-store.js";
+export * from "./file-content.js";
 // UI
 export * from "./style-variant.js";
 export * from "./style-size.js";

package/models/modal.d.ts

@@ -12,6 +12,7 @@ export interface ModalConfig<T = any> {
     headerTitleComponent?: VueComponent;
 }
 export interface Modal<TReturn = any> {
+    id: number;
     config?: ModalConfig;
     closed?: Promise<TReturn>;
     component: VueComponent;

package/models/orgnote-config.d.ts

@@ -56,15 +56,21 @@ export declare const ORG_NOTE_CONFIG_SCHEMA: import("valibot").SchemaWithPipe<re
         readonly privateKey: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MetadataAction<string, {
             readonly textarea: true;
             readonly upload: true;
+            readonly command: import("./default-commands").DefaultCommands.UPLOAD_PRIVATE_KEY;
         }>]>;
         readonly publicKey: import("valibot").SchemaWithPipe<readonly [import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>, import("valibot").MetadataAction<string, {
             readonly textarea: true;
             readonly upload: true;
+            readonly command: import("./default-commands").DefaultCommands.UPLOAD_PUBLIC_KEY;
+        }>]>;
+        readonly privateKeyPassphrase: import("valibot").SchemaWithPipe<readonly [import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>, import("valibot").MetadataAction<string, {
+            readonly password: true;
         }>]>;
-        readonly privateKeyPassphrase: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
     }, undefined>, import("valibot").ObjectSchema<{
         readonly type: import("valibot").LiteralSchema<"gpgPassword", undefined>;
-        readonly password: import("valibot").StringSchema<undefined>;
+        readonly password: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MetadataAction<string, {
+            readonly password: true;
+        }>]>;
     }, undefined>, import("valibot").ObjectSchema<{
         readonly type: import("valibot").LiteralSchema<"disabled", undefined>;
     }, undefined>], undefined>, import("valibot").MetadataAction<{

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orgnote-api",
-  "version": "0.41.13",
+  "version": "0.41.15",
   "description": "Official API for creating extensions for OrgNote app",
   "type": "module",
   "main": "./index.js",

package/utils/__tests__/is-gpg-encrypted.spec.js

@@ -1,5 +1,5 @@
 import { expect, test } from 'vitest';
-import { isGpgEncrypted } from "../is-gpg-encrypted.js";
+import { isArmoredPgp, isGpgEncrypted } from "../is-gpg-encrypted.js";
 test('Should return true if the content is gpg encrypted', () => {
     const content = `-----BEGIN PGP MESSAGE-----
 
@@ -38,3 +38,29 @@ test('Should return false if the content is not gpg encrypted', () => {
     const content = `Hello World!`;
     expect(isGpgEncrypted(content)).toBe(false);
 });
+test('isArmoredPgp should return true for armored PGP string', () => {
+    const armored = `-----BEGIN PGP MESSAGE-----\n\nbase64data\n-----END PGP MESSAGE-----`;
+    expect(isArmoredPgp(armored)).toBe(true);
+});
+test('isArmoredPgp should return true for armored PGP public key', () => {
+    const armored = `-----BEGIN PGP PUBLIC KEY BLOCK-----\n\nkeydata\n-----END PGP PUBLIC KEY BLOCK-----`;
+    expect(isArmoredPgp(armored)).toBe(true);
+});
+test('isArmoredPgp should return false for plain text string', () => {
+    expect(isArmoredPgp('Hello World!')).toBe(false);
+});
+test('isArmoredPgp should return false for empty string', () => {
+    expect(isArmoredPgp('')).toBe(false);
+});
+test('isArmoredPgp should return true for Uint8Array with armored PGP header', () => {
+    const armored = '-----BEGIN PGP MESSAGE-----\n\ndata';
+    const bytes = new TextEncoder().encode(armored);
+    expect(isArmoredPgp(bytes)).toBe(true);
+});
+test('isArmoredPgp should return false for Uint8Array with binary content', () => {
+    const bytes = new Uint8Array([0x99, 0x01, 0x0d, 0x04, 0x5e]);
+    expect(isArmoredPgp(bytes)).toBe(false);
+});
+test('isArmoredPgp should return false for empty Uint8Array', () => {
+    expect(isArmoredPgp(new Uint8Array(0))).toBe(false);
+});

package/utils/is-gpg-encrypted.d.ts

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

package/utils/is-gpg-encrypted.js

@@ -1,3 +1,11 @@
+const PGP_ARMOR_HEADER = '-----BEGIN PGP';
+export function isArmoredPgp(content) {
+    if (typeof content === 'string') {
+        return content.startsWith(PGP_ARMOR_HEADER);
+    }
+    const header = String.fromCharCode(...content.slice(0, PGP_ARMOR_HEADER.length));
+    return header === PGP_ARMOR_HEADER;
+}
 export function isGpgEncrypted(text) {
     if (text instanceof Uint8Array) {
         return true;