@platless/axom-cli 0.1.0 → 0.5.9

package/dist/workstation/keepers/kit/client.js

@@ -0,0 +1,432 @@
+// Daemon-side half of the kit. Exempt from the keeper-side import guard (it may be imported by daemon modules).
+import { EventEmitter } from 'node:events';
+import { promises as fs } from 'node:fs';
+import net from 'node:net';
+import { encodeFrame, LineDecoder, parseClientBound } from './ipc.js';
+import { frameLimitsOf, inProtocolWindow, WINDOW_EXEMPT_METHODS, } from './protocol.js';
+/** The keeper answered with `ok:false`. */
+export class KeeperRequestError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'KeeperRequestError';
+    }
+}
+/** The connection broke while the request was in flight. The request MAY have been executed: requests are never retried, reconcile by the keeper's own state. */
+export class KeeperConnectionLostError extends Error {
+    code = 'connection_lost';
+    constructor(message = 'Keeper connection lost') { super(message); this.name = 'KeeperConnectionLostError'; }
+}
+export class KeeperRequestTimeoutError extends Error {
+    code = 'timeout';
+    constructor(method) { super(`Keeper request ${method} timed out`); this.name = 'KeeperRequestTimeoutError'; }
+}
+export class KeeperNotConnectedError extends Error {
+    code = 'not_connected';
+    constructor(message = 'Keeper is not connected') { super(message); this.name = 'KeeperNotConnectedError'; }
+}
+export class KeeperClosedError extends Error {
+    code = 'closed';
+    constructor() { super('Keeper client is closed'); this.name = 'KeeperClosedError'; }
+}
+export class KeeperFrameTooLargeError extends Error {
+    code = 'frame_too_large';
+    constructor(size, limit) { super(`Request frame of ${size} bytes exceeds the ${limit} byte limit`); this.name = 'KeeperFrameTooLargeError'; }
+}
+/** The keeper's protocol is outside the daemon's `[N-1, N]` window: it has to be replaced. Only the `keeper.*` management methods still work. */
+export class KeeperReplacementRequiredError extends Error {
+    hello;
+    daemonProtocol;
+    code = 'replacement_required';
+    constructor(hello, daemonProtocol) {
+        super(`Keeper protocol ${hello.protocolVersion} is outside the supported window [${daemonProtocol[0]}, ${daemonProtocol[1]}]`);
+        this.hello = hello;
+        this.daemonProtocol = daemonProtocol;
+        this.name = 'KeeperReplacementRequiredError';
+    }
+}
+/**
+ * Reads the connection token. The file must be a regular file (never a symlink), owned by this user and private
+ * (no group/other bits): a token anyone else could have planted or read authenticates nothing.
+ */
+export async function readKeeperToken(tokenFile) {
+    const stat = await fs.lstat(tokenFile);
+    if (stat.isSymbolicLink() || !stat.isFile())
+        throw new Error('Unsafe keeper token file: not a regular file');
+    if (process.getuid && stat.uid !== process.getuid())
+        throw new Error('Unsafe keeper token file: owned by another user');
+    if ((stat.mode & 0o077) !== 0)
+        throw new Error('Unsafe keeper token file: readable by group or others');
+    const token = (await fs.readFile(tokenFile, 'utf8')).trim();
+    if (!token)
+        throw new Error('Empty keeper token');
+    return token;
+}
+/** One socket: request/response correlation plus an `evt` hook. Never reused after it closes. */
+class Link {
+    socket;
+    limits;
+    onEvt;
+    onClose;
+    nextId = 1;
+    pending = new Map();
+    decoder;
+    dead = false;
+    constructor(socket, limits, onEvt, onClose) {
+        this.socket = socket;
+        this.limits = limits;
+        this.onEvt = onEvt;
+        this.onClose = onClose;
+        this.decoder = new LineDecoder(limits.out); // per socket: a torn line is never completed by another connection's bytes
+        socket.on('data', (chunk) => this.onData(chunk));
+        socket.on('error', (error) => this.destroy(new KeeperConnectionLostError(error.message)));
+        socket.on('close', () => this.destroy(new KeeperConnectionLostError('Keeper closed the connection')));
+    }
+    get isDead() { return this.dead; }
+    onData(chunk) {
+        let frames;
+        try {
+            frames = this.decoder.push(chunk).map(parseClientBound);
+        }
+        catch (error) {
+            this.destroy(new KeeperConnectionLostError(`Invalid keeper frame: ${error.message}`));
+            return;
+        }
+        for (const frame of frames) {
+            if (this.dead)
+                return;
+            if (frame.t === 'evt') {
+                this.onEvt(frame);
+                continue;
+            }
+            const entry = this.pending.get(frame.id);
+            if (!entry)
+                continue; // a late answer to a timed-out request
+            this.pending.delete(frame.id);
+            clearTimeout(entry.timer);
+            if (frame.ok)
+                entry.resolve(frame.result ?? {});
+            else {
+                const e = frame.error;
+                entry.reject(typeof e === 'object' && e !== null ? new KeeperRequestError(e.code, e.message) : new KeeperRequestError('error', typeof e === 'string' ? e : 'Keeper request failed'));
+            }
+        }
+    }
+    request(method, params, timeoutMs) {
+        if (this.dead)
+            return Promise.reject(new KeeperConnectionLostError());
+        const id = this.nextId++;
+        let encoded;
+        try {
+            encoded = encodeFrame({ t: 'req', id, method, params });
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+        if (encoded.length > this.limits.in)
+            return Promise.reject(new KeeperFrameTooLargeError(encoded.length, this.limits.in));
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => { this.pending.delete(id); reject(new KeeperRequestTimeoutError(method)); }, timeoutMs);
+            this.pending.set(id, { resolve, reject, timer });
+            this.socket.write(encoded.data);
+        });
+    }
+    sendFrame(frame) { if (!this.dead)
+        this.socket.write(encodeFrame(frame).data); }
+    destroy(error) {
+        if (this.dead)
+            return;
+        this.dead = true;
+        for (const entry of this.pending.values()) {
+            clearTimeout(entry.timer);
+            entry.reject(error);
+        }
+        this.pending.clear();
+        this.socket.destroy();
+        this.onClose(error);
+    }
+}
+function connectLink(socketPath, limits, timeoutMs, onEvt, onClose) {
+    return new Promise((resolve, reject) => {
+        const socket = net.createConnection(socketPath);
+        let settled = false;
+        const timer = setTimeout(() => fail(new KeeperNotConnectedError('Timed out connecting to the keeper')), timeoutMs);
+        const fail = (error) => { if (settled)
+            return; settled = true; clearTimeout(timer); socket.destroy(); reject(error); };
+        socket.once('error', (error) => fail(new KeeperNotConnectedError(error.message)));
+        socket.once('connect', () => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            socket.removeAllListeners('error');
+            resolve(new Link(socket, limits, onEvt, onClose));
+        });
+    });
+}
+/**
+ * One request on a fresh connection (probe, diagnostics, graceful stop). `keeper.ping` needs no token; anything else
+ * passes `options.token`. This is the "one connection, one request" form the spec keeps for legacy probes.
+ */
+export async function keeperOneShot(socketPath, method, params = {}, timeoutMs = 2000, options = {}) {
+    const deadline = Date.now() + timeoutMs;
+    const link = await connectLink(socketPath, frameLimitsOf(options.kind), timeoutMs, () => { }, () => { });
+    try {
+        if (options.token !== undefined)
+            await link.request('keeper.hello', { token: options.token, daemonProtocol: options.daemonProtocol ?? [0, 0xffff] }, Math.max(1, deadline - Date.now()));
+        return await link.request(method, params, Math.max(1, deadline - Date.now()));
+    }
+    finally {
+        link.destroy(new KeeperClosedError());
+    }
+}
+const subscribeParams = (sub) => ({ stream: sub.stream, from: sub.next, credit: sub.window, ...(sub.windowBytes !== undefined ? { creditBytes: sub.windowBytes } : {}) });
+const DEFAULT_WINDOW = 256;
+/**
+ * One long-lived duplex connection to one keeper generation. Reconnects on its own after a drop; requests are never
+ * retried (an in-flight one fails with `KeeperConnectionLostError`); stream subscriptions resume from the offset after the
+ * last record delivered. Emits `state` (KeeperClientState), `connected` (KeeperHello) and `disconnected` (Error).
+ */
+export class KeeperClient extends EventEmitter {
+    options;
+    link;
+    epoch = 0;
+    current = 'idle';
+    helloValue;
+    opening;
+    reconnectTimer;
+    backoff;
+    everConnected = false;
+    subs = new Map();
+    waiters = new Set();
+    constructor(options) {
+        super();
+        this.options = options;
+        this.backoff = options.reconnectMinMs ?? 50;
+    }
+    get state() { return this.current; }
+    get hello() { return this.helloValue; }
+    /** `'required'` when the connected keeper's protocol is outside the daemon's window. */
+    get replacement() { return this.current === 'replacement-required' ? 'required' : undefined; }
+    setState(state) { if (this.current !== state) {
+        this.current = state;
+        this.emit('state', state);
+    } }
+    get requestTimeout() { return this.options.requestTimeoutMs ?? 30_000; }
+    get connectTimeout() { return this.options.connectTimeoutMs ?? 3000; }
+    /** Connects and says hello once; rejects on failure. After a later drop the client reconnects by itself. */
+    connect() {
+        if (this.current === 'closed')
+            return Promise.reject(new KeeperClosedError());
+        if (this.link && !this.link.isDead && this.helloValue)
+            return Promise.resolve(this.resultOf(this.helloValue));
+        if (!this.opening) {
+            this.opening = this.openOnce().finally(() => { this.opening = undefined; });
+            this.opening.catch(() => { if (this.everConnected && this.current !== 'closed')
+                this.scheduleReconnect(); });
+        }
+        return this.opening;
+    }
+    resultOf(hello) {
+        return inProtocolWindow(this.options.daemonProtocol, hello.protocolVersion)
+            ? { status: 'ready', hello }
+            : { status: 'replacement-required', replacement: 'required', hello, daemonProtocol: this.options.daemonProtocol };
+    }
+    async openOnce() {
+        this.setState('connecting');
+        let link;
+        try {
+            const token = await readKeeperToken(this.options.tokenFile);
+            const epoch = ++this.epoch;
+            link = await connectLink(this.options.socket, frameLimitsOf(this.options.kind), this.connectTimeout, (frame) => this.onEvt(epoch, frame), (error) => this.onLinkClosed(epoch, error));
+            this.link = link;
+            const hello = await link.request('keeper.hello', { token, daemonProtocol: [...this.options.daemonProtocol] }, this.connectTimeout);
+            if (hello.kind !== this.options.kind || (this.options.gen !== undefined && hello.gen !== this.options.gen) || !Number.isSafeInteger(hello.protocolVersion))
+                throw new KeeperRequestError('identity_mismatch', 'The keeper at this socket is not the expected kind or generation');
+            this.helloValue = hello;
+            this.everConnected = true;
+            this.backoff = this.options.reconnectMinMs ?? 50;
+            const result = this.resultOf(hello);
+            this.setState(result.status === 'ready' ? 'ready' : 'replacement-required');
+            this.emit('connected', hello);
+            this.flushWaiters();
+            if (result.status === 'ready')
+                this.resubscribeAll(link, epoch);
+            else
+                this.failSubscriptions(new KeeperReplacementRequiredError(hello, this.options.daemonProtocol));
+            return result;
+        }
+        catch (error) {
+            if (link) {
+                this.link = undefined;
+                link.destroy(error instanceof Error ? error : new Error(String(error)));
+            }
+            this.helloValue = undefined;
+            if (this.current !== 'closed')
+                this.setState(this.everConnected ? 'connecting' : 'idle');
+            throw error;
+        }
+    }
+    onLinkClosed(epoch, error) {
+        if (epoch !== this.epoch || this.current === 'closed')
+            return;
+        if (this.link) { // an established connection dropped (a failing hello is handled by openOnce)
+            this.link = undefined;
+            this.helloValue = undefined;
+            if (this.opening)
+                return;
+            this.setState('connecting');
+            this.emit('disconnected', error);
+            this.scheduleReconnect();
+        }
+    }
+    scheduleReconnect() {
+        if (this.reconnectTimer || this.current === 'closed')
+            return;
+        const delay = this.backoff;
+        this.backoff = Math.min(this.options.reconnectMaxMs ?? 2000, this.backoff * 2);
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = undefined;
+            this.connect().catch(() => { });
+        }, delay);
+        this.reconnectTimer.unref();
+    }
+    flushWaiters() { for (const w of this.waiters) {
+        clearTimeout(w.timer);
+        w.resolve();
+    } this.waiters.clear(); }
+    async ready() {
+        if (this.current === 'closed')
+            throw new KeeperClosedError();
+        if (this.current === 'idle')
+            await this.connect();
+        else if (this.current === 'connecting') {
+            await new Promise((resolve, reject) => {
+                const waiter = { resolve, reject, timer: setTimeout(() => { this.waiters.delete(waiter); reject(new KeeperNotConnectedError('Keeper is reconnecting')); }, this.connectTimeout) };
+                this.waiters.add(waiter);
+                this.connect().catch(() => { }); // joins the attempt in flight or starts one
+            });
+        }
+        if (!this.link || this.link.isDead)
+            throw new KeeperNotConnectedError();
+        return this.link;
+    }
+    /** One request. Never retried: if the connection breaks while it is in flight it fails with `KeeperConnectionLostError`. */
+    async request(method, params = {}, options = {}) {
+        const link = await this.ready();
+        if (this.current === 'replacement-required' && !WINDOW_EXEMPT_METHODS.has(method))
+            throw new KeeperReplacementRequiredError(this.helloValue, this.options.daemonProtocol);
+        return await link.request(method, params, options.timeoutMs ?? this.requestTimeout);
+    }
+    /**
+     * Streams `stream` into `handler`, in order, with credit-based backpressure: the keeper pushes at most `window` records
+     * ahead of what `handler` has finished. After a reconnect the subscription continues from the offset after the last
+     * record delivered; nothing is delivered twice.
+     */
+    async subscribe(stream, handler, options) {
+        const link = await this.ready();
+        if (this.current === 'replacement-required')
+            throw new KeeperReplacementRequiredError(this.helloValue, this.options.daemonProtocol);
+        const sub = {
+            stream, handler, onClosed: options.onClosed, window: options.window ?? DEFAULT_WINDOW,
+            ...(options.windowBytes !== undefined ? { windowBytes: options.windowBytes } : {}),
+            next: options.from, chain: Promise.resolve(), cancelled: false, epoch: this.epoch,
+        };
+        const previous = this.subs.get(stream);
+        if (previous)
+            previous.cancelled = true;
+        this.subs.set(stream, sub); // before the request: records may arrive right behind the reply
+        try {
+            await link.request('keeper.subscribe', subscribeParams(sub), this.requestTimeout);
+        }
+        catch (error) {
+            if (this.subs.get(stream) === sub)
+                this.subs.delete(stream);
+            throw error;
+        }
+        const owner = this;
+        return {
+            stream,
+            get nextOffset() { return sub.next; },
+            async unsubscribe() {
+                sub.cancelled = true;
+                if (owner.subs.get(stream) === sub)
+                    owner.subs.delete(stream);
+                if (owner.link && !owner.link.isDead)
+                    await owner.link.request('keeper.unsubscribe', { stream }, owner.requestTimeout).catch(() => { });
+            },
+        };
+    }
+    onEvt(epoch, frame) {
+        if (epoch !== this.epoch)
+            return;
+        const sub = this.subs.get(frame.stream);
+        if (!sub || sub.cancelled)
+            return;
+        if (frame.closed !== undefined) {
+            this.subs.delete(frame.stream);
+            sub.cancelled = true;
+            sub.onClosed?.(new KeeperRequestError(frame.closed, `Keeper ended stream ${frame.stream}: ${frame.closed}`));
+            return;
+        }
+        const received = frame.records.length;
+        const fresh = frame.records.filter((r) => r.o >= sub.next);
+        if (fresh.length > 0)
+            sub.next = fresh[fresh.length - 1].o + 1;
+        sub.chain = sub.chain.then(async () => {
+            if (sub.cancelled)
+                return;
+            if (fresh.length > 0)
+                await sub.handler(fresh);
+            if (!sub.cancelled && this.epoch === epoch) {
+                this.link?.sendFrame({ t: 'credit', stream: sub.stream, n: received, ...(typeof frame.bytes === 'number' ? { bytes: frame.bytes } : {}) });
+            }
+        }).catch((error) => {
+            this.subs.delete(sub.stream);
+            sub.cancelled = true;
+            sub.onClosed?.(error instanceof Error ? error : new Error(String(error)));
+        });
+    }
+    /** Live subscriptions cannot continue on a keeper that now needs replacing: tell their owners instead of leaving them silent. */
+    failSubscriptions(error) {
+        for (const sub of [...this.subs.values()]) {
+            sub.cancelled = true;
+            sub.onClosed?.(error);
+        }
+        this.subs.clear();
+    }
+    resubscribeAll(link, epoch) {
+        for (const sub of [...this.subs.values()]) {
+            sub.epoch = epoch;
+            link.request('keeper.subscribe', subscribeParams(sub), this.requestTimeout).catch((error) => {
+                if (this.subs.get(sub.stream) !== sub || this.epoch !== epoch)
+                    return; // superseded, or the link died again (the next reconnect resumes it)
+                if (error instanceof KeeperConnectionLostError || error instanceof KeeperRequestTimeoutError)
+                    return;
+                this.subs.delete(sub.stream);
+                sub.cancelled = true;
+                sub.onClosed?.(error instanceof Error ? error : new Error(String(error)));
+            });
+        }
+    }
+    close() {
+        if (this.current === 'closed')
+            return;
+        this.setState('closed');
+        clearTimeout(this.reconnectTimer);
+        this.reconnectTimer = undefined;
+        for (const sub of this.subs.values())
+            sub.cancelled = true;
+        this.subs.clear();
+        for (const w of this.waiters) {
+            clearTimeout(w.timer);
+            w.reject(new KeeperClosedError());
+        }
+        this.waiters.clear();
+        const link = this.link;
+        this.link = undefined;
+        this.helloValue = undefined;
+        link?.destroy(new KeeperClosedError());
+    }
+}

package/dist/workstation/keepers/kit/identity.js

@@ -0,0 +1,21 @@
+import { createHash } from 'node:crypto';
+import path from 'node:path';
+export const KEEPER_KINDS = ['terminal', 'acp'];
+export const KEEPER_NAMESPACE = 'keeper/1';
+/** sha256(JSON[resolve(configDir), workstationId, server, 'keeper/1', kind])[:32]. Spec §3.1. */
+export function keeperIdentity(input, kind) {
+    return createHash('sha256')
+        .update(JSON.stringify([path.resolve(input.configDir), input.workstationId, input.server, KEEPER_NAMESPACE, kind]))
+        .digest('hex')
+        .slice(0, 32);
+}
+/** A "generation" is the first 8 hex digits of the keeper build; two generations of one kind may coexist. */
+export function keeperGen(buildVersion) {
+    if (!/^[0-9a-f]{8,}$/.test(buildVersion))
+        throw new Error('Invalid keeper buildVersion');
+    return buildVersion.slice(0, 8);
+}
+/** systemd unit name (Linux) and the human-readable id of a keeper generation. */
+export function keeperUnit(kind, identity, gen) {
+    return `axom-keeper-${kind}-${identity}-${gen}`;
+}

package/dist/workstation/keepers/kit/ipc.js

@@ -0,0 +1,112 @@
+export class FrameError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = 'FrameError';
+    }
+}
+const NEWLINE = 0x0a;
+/**
+ * Incremental line splitter for ONE socket. It must never be shared between connections: a torn line from
+ * one peer would otherwise be completed by bytes of another. Chunks are only concatenated once a full line
+ * is present, and a line longer than `maxBytes` (newline excluded) is rejected as soon as it is seen, even
+ * before its newline arrives, so a hostile peer cannot make the buffer grow without bound.
+ */
+export class LineDecoder {
+    maxBytes;
+    chunks = [];
+    pending = 0;
+    constructor(maxBytes) {
+        this.maxBytes = maxBytes;
+    }
+    /** Changes the cap for lines not yet completed (used once a peer has authenticated). */
+    setMax(maxBytes) { this.maxBytes = maxBytes; }
+    /** Bytes of an incomplete trailing line currently buffered. */
+    get buffered() { return this.pending; }
+    push(chunk) {
+        const lines = [];
+        let start = 0;
+        for (;;) {
+            const newline = chunk.indexOf(NEWLINE, start);
+            if (newline < 0)
+                break;
+            const tail = chunk.subarray(start, newline);
+            const length = this.pending + tail.length;
+            if (length > this.maxBytes)
+                throw new FrameError(`Frame exceeds ${this.maxBytes} bytes`, 'too_large');
+            lines.push(this.chunks.length === 0 ? Buffer.from(tail) : Buffer.concat([...this.chunks, tail], length));
+            this.chunks = [];
+            this.pending = 0;
+            start = newline + 1;
+        }
+        if (start < chunk.length) {
+            const rest = chunk.subarray(start);
+            if (this.pending + rest.length > this.maxBytes)
+                throw new FrameError(`Frame exceeds ${this.maxBytes} bytes`, 'too_large');
+            this.chunks.push(Buffer.from(rest));
+            this.pending += rest.length;
+        }
+        return lines;
+    }
+}
+/** A frame as bytes including the terminating newline. `length` is the line length without it (what the cap applies to). */
+export function encodeFrame(frame) {
+    const body = Buffer.from(JSON.stringify(frame), 'utf8');
+    return { data: Buffer.concat([body, Buffer.from('\n')]), length: body.length };
+}
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const isId = (value) => Number.isSafeInteger(value) && value >= 0;
+const malformed = (what) => { throw new FrameError(`Malformed frame: ${what}`, 'malformed'); };
+function parseJsonObject(line) {
+    let value;
+    try {
+        value = JSON.parse(line.toString('utf8'));
+    }
+    catch {
+        return malformed('not JSON');
+    }
+    return isRecord(value) ? value : malformed('not an object');
+}
+/** A frame the keeper may receive. Throws `FrameError` for anything else; the caller destroys that connection. */
+export function parseServerBound(line) {
+    const frame = parseJsonObject(line);
+    if (frame.t === 'req') {
+        if (!isId(frame.id))
+            malformed('req id');
+        if (typeof frame.method !== 'string' || frame.method.length === 0 || frame.method.length > 128)
+            malformed('req method');
+        if (frame.params !== undefined && !isRecord(frame.params))
+            malformed('req params');
+        return frame;
+    }
+    if (frame.t === 'credit') {
+        if (typeof frame.stream !== 'string' || frame.stream.length === 0)
+            malformed('credit stream');
+        if (!Number.isSafeInteger(frame.n) || frame.n <= 0)
+            malformed('credit n');
+        if (frame.bytes !== undefined && (!Number.isSafeInteger(frame.bytes) || frame.bytes < 0))
+            malformed('credit bytes');
+        return frame;
+    }
+    return malformed('unexpected frame type');
+}
+/** A frame the daemon may receive. */
+export function parseClientBound(line) {
+    const frame = parseJsonObject(line);
+    if (frame.t === 'res') {
+        if (!isId(frame.id))
+            malformed('res id');
+        if (typeof frame.ok !== 'boolean')
+            malformed('res ok');
+        return frame;
+    }
+    if (frame.t === 'evt') {
+        if (typeof frame.stream !== 'string')
+            malformed('evt stream');
+        if (!Array.isArray(frame.records) || !frame.records.every((r) => isRecord(r) && Number.isSafeInteger(r.o)))
+            malformed('evt records');
+        return frame;
+    }
+    return malformed('unexpected frame type');
+}

package/dist/workstation/keepers/kit/launchConfig.js

@@ -0,0 +1,8 @@
+export function launchConfigOf(paths, buildVersion, bundleDir, umask) {
+    return {
+        kind: paths.kind, identity: paths.identity, gen: paths.gen, unit: paths.unit, buildVersion, bundleDir,
+        runDir: paths.runDir, dataDir: paths.dataDir, socket: paths.socket, pidFile: paths.pidFile, tokenFile: paths.tokenFile, umask,
+    };
+}
+export const encodeLaunchConfig = (config) => Buffer.from(JSON.stringify(config)).toString('base64');
+export const decodeLaunchConfig = (encoded) => JSON.parse(Buffer.from(encoded, 'base64').toString('utf8'));