@kokuin/electron 0.1.0

package/README.md

@@ -0,0 +1,7 @@
+# @kokuin/electron
+
+## Installation
+
+```sh
+npm install @kokuin/electron
+```

package/lib/entry.d.ts

@@ -0,0 +1,15 @@
+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);
+    get keyID(): string;
+    getAsync(): Promise<string | null>;
+    get(): string | null;
+    setAsync(key: string): Promise<void>;
+    set(key: string): void;
+    provideAsync(): Promise<string>;
+    provide(): string;
+    removeAsync(): Promise<void>;
+    remove(): void;
+}

package/lib/entry.js

@@ -0,0 +1,71 @@
+import { randomPrivateKey } from '@kokuin/token';
+import { fromB64, toB64 } from '@sozai/codec';
+import { safeStorage } from 'electron';
+function encryptKey(encoded) {
+    return toB64(safeStorage.encryptString(encoded));
+}
+function decryptKey(encrypted) {
+    return safeStorage.decryptString(Buffer.from(fromB64(encrypted)));
+}
+// Stored as base64
+export class ElectronKeyEntry {
+    #keyID;
+    #key;
+    #storage;
+    constructor(storage, keyID, key){
+        this.#keyID = keyID;
+        this.#key = key;
+        this.#storage = storage;
+    }
+    get keyID() {
+        return this.#keyID;
+    }
+    getAsync() {
+        return Promise.resolve(this.get());
+    }
+    get() {
+        if (this.#key != null) {
+            return this.#key;
+        }
+        const encrypted = this.#storage.getKeys()[this.#keyID];
+        if (encrypted == null) {
+            return null;
+        }
+        const key = decryptKey(encrypted);
+        if (key == null) {
+            return null;
+        }
+        this.#key = key;
+        return this.#key;
+    }
+    setAsync(key) {
+        return Promise.resolve(this.set(key));
+    }
+    set(key) {
+        const encrypted = encryptKey(key);
+        this.#storage.setKeys({
+            [this.#keyID]: encrypted
+        });
+        this.#key = key;
+    }
+    provideAsync() {
+        return Promise.resolve(this.provide());
+    }
+    provide() {
+        const existing = this.get();
+        if (existing != null) {
+            return existing;
+        }
+        const privateKey = toB64(randomPrivateKey());
+        this.set(privateKey);
+        return privateKey;
+    }
+    removeAsync() {
+        return Promise.resolve(this.remove());
+    }
+    remove() {
+        const { [this.#keyID]: _, ...keys } = this.#storage.getKeys();
+        this.#storage.setKeys(keys);
+        this.#key = undefined;
+    }
+}

package/lib/identity.d.ts

@@ -0,0 +1,4 @@
+import { type FullIdentity } from '@kokuin/token';
+import { ElectronKeyStore } from './store.js';
+export declare function provideFullIdentity(store: ElectronKeyStore | string, keyID: string): FullIdentity;
+export declare function provideFullIdentityAsync(store: ElectronKeyStore | string, keyID: string): Promise<FullIdentity>;

package/lib/identity.js

@@ -0,0 +1,60 @@
+import { createFullIdentity, decodePrivateKey } from '@kokuin/token';
+import { getLogger } from '@sozai/log';
+import { AttributeKeys, createTracer, SpanNames, withSpan, withSyncSpan } from '@sozai/otel';
+import { ElectronKeyStore } from './store.js';
+const tracer = createTracer('keystore.electron');
+const logger = getLogger([
+    'kokuin',
+    'electron'
+]);
+function getStore(store) {
+    return typeof store === 'string' ? ElectronKeyStore.open(store) : store;
+}
+export function provideFullIdentity(store, keyID) {
+    return withSyncSpan(tracer, SpanNames.KEYSTORE_GET_OR_CREATE, {
+        attributes: {
+            [AttributeKeys.KEYSTORE_STORE_TYPE]: 'electron'
+        }
+    }, (span)=>{
+        const entry = getStore(store).entry(keyID);
+        const existing = entry.get();
+        if (existing != null) {
+            const identity = createFullIdentity(decodePrivateKey(existing));
+            span.setAttribute(AttributeKeys.AUTH_DID, identity.id);
+            span.setAttribute(AttributeKeys.KEYSTORE_KEY_CREATED, false);
+            return identity;
+        }
+        const key = entry.provide();
+        const identity = createFullIdentity(decodePrivateKey(key));
+        span.setAttribute(AttributeKeys.AUTH_DID, identity.id);
+        span.setAttribute(AttributeKeys.KEYSTORE_KEY_CREATED, true);
+        logger.info('New identity generated: {did}', {
+            did: identity.id
+        });
+        return identity;
+    });
+}
+export async function provideFullIdentityAsync(store, keyID) {
+    return withSpan(tracer, SpanNames.KEYSTORE_GET_OR_CREATE, {
+        attributes: {
+            [AttributeKeys.KEYSTORE_STORE_TYPE]: 'electron'
+        }
+    }, async (span)=>{
+        const entry = getStore(store).entry(keyID);
+        const existing = await entry.getAsync();
+        if (existing != null) {
+            const identity = createFullIdentity(decodePrivateKey(existing));
+            span.setAttribute(AttributeKeys.AUTH_DID, identity.id);
+            span.setAttribute(AttributeKeys.KEYSTORE_KEY_CREATED, false);
+            return identity;
+        }
+        const key = await entry.provideAsync();
+        const identity = createFullIdentity(decodePrivateKey(key));
+        span.setAttribute(AttributeKeys.AUTH_DID, identity.id);
+        span.setAttribute(AttributeKeys.KEYSTORE_KEY_CREATED, true);
+        logger.info('New identity generated: {did}', {
+            did: identity.id
+        });
+        return identity;
+    });
+}

package/lib/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Electron keystore.
+ *
+ * ## Installation
+ *
+ * ```sh
+ * npm install @kokuin/electron
+ * ```
+ *
+ * @module electron-keystore
+ */
+export { ElectronKeyEntry } from './entry.js';
+export { provideFullIdentity, provideFullIdentityAsync } from './identity.js';
+export { ElectronKeyStore } from './store.js';

package/lib/index.js

@@ -0,0 +1,13 @@
+/**
+ * Electron keystore.
+ *
+ * ## Installation
+ *
+ * ```sh
+ * npm install @kokuin/electron
+ * ```
+ *
+ * @module electron-keystore
+ */ export { ElectronKeyEntry } from './entry.js';
+export { provideFullIdentity, provideFullIdentityAsync } from './identity.js';
+export { ElectronKeyStore } from './store.js';

package/lib/store.d.ts

@@ -0,0 +1,8 @@
+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);
+    entry(keyID: string): ElectronKeyEntry;
+}

package/lib/store.js

@@ -0,0 +1,39 @@
+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);
+        }
+        return ElectronKeyStore.#byName[name];
+    }
+    #entries = {};
+    #storage;
+    constructor(name){
+        const store = new Store({
+            name,
+            schema: {
+                keys: {
+                    type: 'object',
+                    properties: {
+                        key: {
+                            type: 'string'
+                        }
+                    }
+                }
+            },
+            defaults: {
+                keys: {}
+            }
+        });
+        this.#storage = {
+            getKeys: ()=>store.get('keys', {}),
+            setKeys: (keys)=>store.set('keys', keys)
+        };
+    }
+    entry(keyID) {
+        this.#entries[keyID] ??= new ElectronKeyEntry(this.#storage, keyID);
+        return this.#entries[keyID];
+    }
+}

package/lib/types.d.ts

@@ -0,0 +1,4 @@
+export type KeyStorage = {
+    getKeys: () => Record<string, string>;
+    setKeys: (keys: Record<string, string>) => void;
+};

package/lib/types.js

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

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@kokuin/electron",
+  "version": "0.1.0",
+  "license": "MIT",
+  "description": "Electron keystore",
+  "keywords": [
+    "cryptography",
+    "key-management",
+    "electron",
+    "storage"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/TairuFramework/kokuin",
+    "directory": "packages/electron"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "exports": {
+    ".": "./lib/index.js"
+  },
+  "files": [
+    "lib/*"
+  ],
+  "sideEffects": false,
+  "dependencies": {
+    "@sozai/codec": "^0.1.0",
+    "@sozai/log": "^0.1.0",
+    "@sozai/otel": "^0.1.0",
+    "electron-store": "^11.0.2",
+    "@kokuin/token": "^0.1.0"
+  },
+  "devDependencies": {
+    "electron": "^42.4.1"
+  },
+  "scripts": {
+    "build:clean": "del lib",
+    "build:js": "swc src -d ./lib --config-file ../../node_modules/@kigu/dev/swc.json --strip-leading-paths",
+    "build:types": "tsc --emitDeclarationOnly --skipLibCheck",
+    "build": "pnpm run build:clean && pnpm run build:js && pnpm run build:types",
+    "test:types": "tsc --noEmit --skipLibCheck -p tsconfig.test.json",
+    "test:unit": "vitest run",
+    "test": "pnpm run test:types && pnpm run test:unit"
+  }
+}