@kokuin/electron 0.1.1 → 0.3.0

package/lib/entry.d.ts

@@ -2,7 +2,7 @@ import type { KeyEntry } from '@kokuin/token';
 import type { KeyStorage } from './types.js';
 export declare class ElectronKeyEntry implements KeyEntry<string> {
     #private;
-    constructor(storage: KeyStorage, keyID: string, key?: string);
+    constructor(storage: KeyStorage, keyID: string, key?: string, allowInsecureStorage?: boolean);
     get keyID(): string;
     getAsync(): Promise<string | null>;
     get(): string | null;

package/lib/entry.js

@@ -12,10 +12,17 @@ export class ElectronKeyEntry {
     #keyID;
     #key;
     #storage;
-    constructor(storage, keyID, key){
+    #allowInsecureStorage;
+    constructor(storage, keyID, key, allowInsecureStorage = false){
         this.#keyID = keyID;
         this.#key = key;
         this.#storage = storage;
+        this.#allowInsecureStorage = allowInsecureStorage;
+    }
+    #assertEncryptionAvailable() {
+        if (!this.#allowInsecureStorage && !safeStorage.isEncryptionAvailable()) {
+            throw new Error('Electron safeStorage encryption is unavailable (e.g. Linux without a keyring); ' + 'refusing to persist a plaintext-equivalent private key. ' + 'Pass { allowInsecureStorage: true } to ElectronKeyStore.open to override.');
+        }
     }
     get keyID() {
         return this.#keyID;
@@ -38,18 +45,19 @@ export class ElectronKeyEntry {
         this.#key = key;
         return this.#key;
     }
-    setAsync(key) {
-        return Promise.resolve(this.set(key));
+    async setAsync(key) {
+        return this.set(key);
     }
     set(key) {
+        this.#assertEncryptionAvailable();
         const encrypted = encryptKey(key);
-        this.#storage.setKeys({
-            [this.#keyID]: encrypted
-        });
+        const keys = this.#storage.getKeys();
+        keys[this.#keyID] = encrypted;
+        this.#storage.setKeys(keys);
         this.#key = key;
     }
-    provideAsync() {
-        return Promise.resolve(this.provide());
+    async provideAsync() {
+        return this.provide();
     }
     provide() {
         const existing = this.get();

package/lib/store.d.ts

@@ -2,7 +2,9 @@ import type { KeyStore } from '@kokuin/token';
 import { ElectronKeyEntry } from './entry.js';
 export declare class ElectronKeyStore implements KeyStore<string, ElectronKeyEntry> {
     #private;
-    static open(name?: string): ElectronKeyStore;
-    constructor(name: string);
+    static open(name?: string, options?: {
+        allowInsecureStorage?: boolean;
+    }): ElectronKeyStore;
+    constructor(name: string, allowInsecureStorage?: boolean);
     entry(keyID: string): ElectronKeyEntry;
 }

package/lib/store.js

@@ -1,16 +1,21 @@
 import Store from 'electron-store';
 import { ElectronKeyEntry } from './entry.js';
 export class ElectronKeyStore {
-    static #byName = {};
-    static open(name = 'keystore') {
-        if (ElectronKeyStore.#byName[name] == null) {
-            ElectronKeyStore.#byName[name] = new ElectronKeyStore(name);
+    static #byName = Object.create(null);
+    static open(name = 'keystore', options) {
+        const cached = ElectronKeyStore.#byName[name];
+        if (cached == null) {
+            ElectronKeyStore.#byName[name] = new ElectronKeyStore(name, options?.allowInsecureStorage ?? false);
+        } else if (options?.allowInsecureStorage != null && options.allowInsecureStorage !== cached.#allowInsecureStorage) {
+            throw new Error(`ElectronKeyStore.open('${name}') was already opened with allowInsecureStorage: ` + `${cached.#allowInsecureStorage}; cannot reopen with conflicting allowInsecureStorage: ` + `${options.allowInsecureStorage}.`);
         }
         return ElectronKeyStore.#byName[name];
     }
-    #entries = {};
+    #entries = Object.create(null);
     #storage;
-    constructor(name){
+    #allowInsecureStorage;
+    constructor(name, allowInsecureStorage = false){
+        this.#allowInsecureStorage = allowInsecureStorage;
         const store = new Store({
             name,
             schema: {
@@ -33,7 +38,7 @@ export class ElectronKeyStore {
         };
     }
     entry(keyID) {
-        this.#entries[keyID] ??= new ElectronKeyEntry(this.#storage, keyID);
+        this.#entries[keyID] ??= new ElectronKeyEntry(this.#storage, keyID, undefined, this.#allowInsecureStorage);
         return this.#entries[keyID];
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kokuin/electron",
-  "version": "0.1.1",
+  "version": "0.3.0",
   "license": "MIT",
   "description": "Electron keystore",
   "keywords": [
@@ -25,15 +25,15 @@
   ],
   "sideEffects": false,
   "dependencies": {
-    "@sozai/codec": "^0.1.0",
+    "@sozai/codec": "^0.2.0",
     "@sozai/log": "^0.1.0",
     "@sozai/otel": "^0.2.0",
     "electron-store": "^11.0.2",
     "@kokuin/otel": "^0.1.0",
-    "@kokuin/token": "^0.1.1"
+    "@kokuin/token": "^0.2.0"
   },
   "devDependencies": {
-    "electron": "^42.5.0"
+    "electron": "^43.1.0"
   },
   "scripts": {
     "build:clean": "del lib",