@glyphteck/veyl 0.1.0 → 0.1.2

package/src/client.js

@@ -1,499 +0,0 @@
-import { Buffer } from 'node:buffer';
-import process from 'node:process';
-import { SparkWallet } from '@buildonspark/spark-sdk';
-import {
-    closeAccountSession,
-    openRegistryAccountSession,
-} from '@veyl/shared/account/session';
-import { createAccountSessionActions } from '@veyl/shared/account/actions';
-import { packSeedData, unpackSeedData } from '@veyl/shared/crypto/pack';
-import { createSecretRegistry, decryptSeed, encryptSeedWithPassword, generateSeed } from '@veyl/shared/crypto/seed';
-import { resolveNetwork } from '@veyl/shared/network';
-import { isUsername, normalizeUsername } from '@veyl/shared/username';
-import { createHeadlessCloud, signInHeadless, signOutHeadless } from './cloud.js';
-import { deriveVaultKey } from './kdf.js';
-import { listenAccount } from './listen.js';
-import { createMachineCredential, signMachineChallenge } from './machine.js';
-import { runPasskeyBrowserFlow } from './passkey.js';
-import { cleanProfileName, ProfileStore } from './storage.js';
-import { serveMcp } from './mcp.js';
-
-export const API_VERSION = 1;
-
-export const COMMANDS = Object.freeze({
-    account: Object.freeze(['create', 'login', 'me']),
-    vault: Object.freeze(['create', 'unlock', 'lock']),
-    chat: Object.freeze(['list', 'read', 'send']),
-    money: Object.freeze(['balance', 'send', 'request', 'pay']),
-    mcp: Object.freeze(['serve']),
-    transactions: Object.freeze(['list']),
-    listen: Object.freeze(['start']),
-});
-
-export class ClientNotReadyError extends Error {
-    constructor(feature) {
-        super(`${feature} is not available`);
-        this.name = 'ClientNotReadyError';
-        this.code = 'client_not_ready';
-    }
-}
-
-function cleanUsername(value) {
-    const username = normalizeUsername(String(value ?? '').trim().replace(/^@+/, ''));
-    if (!isUsername(username)) {
-        throw new Error('valid username required');
-    }
-    return username;
-}
-
-function cleanOptionalUsername(value) {
-    const username = String(value ?? '').trim();
-    return username ? cleanUsername(username) : '';
-}
-
-function randomSecret() {
-    const bytes = new Uint8Array(32);
-    globalThis.crypto.getRandomValues(bytes);
-    return Buffer.from(bytes).toString('base64url');
-}
-
-export class VeylHeadlessClient {
-    constructor(options = {}) {
-        this.options = options;
-        this.network = String(options.network || resolveNetwork(process.env)).toUpperCase();
-        this.store = options.store || new ProfileStore({ dir: options.homeDir, profile: options.profile });
-        this.profile = options.profileData || null;
-        this.session = options.session || null;
-        const cloud = options.cloudContext || createHeadlessCloud(options);
-        this.auth = cloud.auth;
-        this.cloud = cloud.cloud;
-        this.functionBaseUrl = options.functionBaseUrl || cloud.functionBaseUrl;
-        this.actions = createAccountSessionActions({
-            cloud: () => this.cloud,
-            getSession: () => this.ensureUnlocked(),
-        });
-
-        this.account = {
-            create: (payload) => this.createAccount(payload),
-            createPasskey: (payload) => this.createPasskeyAccount(payload),
-            login: (payload) => this.loginAccount(payload),
-            loginPasskey: (payload) => this.loginPasskeyAccount(payload),
-            me: () => this.me(),
-        };
-        this.vault = {
-            create: (payload) => this.createVault(payload),
-            unlock: (payload) => this.unlockVault(payload),
-            lock: (payload) => this.lockVault(payload),
-        };
-        this.chat = {
-            list: (payload) => this.listChats(payload),
-            read: (peer, payload) => this.readChat(peer, payload),
-            send: (peer, message, payload) => this.sendChat(peer, message, payload),
-        };
-        this.money = {
-            balance: (payload) => this.balance(payload),
-            send: (peer, sats, payload) => this.sendMoney(peer, sats, payload),
-            request: (peer, sats, payload) => this.requestMoney(peer, sats, payload),
-            pay: (requestId, payload) => this.payRequest(requestId, payload),
-            transactions: (payload) => this.transactions(payload),
-        };
-        this.mcp = {
-            serve: (payload) => serveMcp(this, payload),
-        };
-        this.listen = (payload) => this.listenEvents(payload);
-    }
-
-    async callAccountEndpoint(path, payload, options = {}) {
-        const headers = { 'Content-Type': 'application/json' };
-        if (options.auth === true) {
-            const token = await this.auth?.currentUser?.getIdToken?.();
-            if (!token) {
-                throw new Error('signed-in account required');
-            }
-            headers.Authorization = `Bearer ${token}`;
-        }
-        const response = await fetch(`${this.functionBaseUrl}${path}`, {
-            method: 'POST',
-            headers,
-            body: JSON.stringify(payload || {}),
-        });
-        const data = await response.json().catch(() => null);
-        if (!response.ok || data?.ok === false) {
-            const error = new Error(data?.message || `headless api failed (${response.status || 0})`);
-            error.code = data?.code || '';
-            error.status = response.status || 0;
-            throw error;
-        }
-        return data;
-    }
-
-    accountSummary(profile = this.profile) {
-        if (!profile) {
-            return null;
-        }
-        return {
-            uid: profile.uid,
-            username: profile.username,
-            profile: profile.profile,
-            credentialId: profile.credentialId,
-            network: profile.network || this.network,
-            hasVault: profile.hasVault === true,
-            hasVaultSecret: !!profile.vaultSecret,
-            walletPK: profile.walletPK || null,
-            chatPK: profile.chatPK || null,
-            auth: profile.auth || 'machine',
-            signedIn: this.auth?.currentUser?.uid === profile.uid,
-            unlocked: !!this.session,
-        };
-    }
-
-    async saveProfile(profile) {
-        this.profile = await this.store.save(profile);
-        return this.profile;
-    }
-
-    async loadProfile(profileName = '') {
-        if (this.profile && (!profileName || cleanProfileName(profileName) === this.profile.profile)) {
-            return this.profile;
-        }
-        this.profile = await this.store.require(profileName);
-        this.network = String(this.profile.network || this.network).toUpperCase();
-        return this.profile;
-    }
-
-    async createAccount(options = {}) {
-        const username = cleanUsername(options.username);
-        const network = String(options.network || this.network).toUpperCase();
-        const machine = options.credential || createMachineCredential();
-        const start = await this.callAccountEndpoint('/account/create/start', {
-            username,
-            publicKeyPem: machine.publicKeyPem,
-        });
-        const finish = await this.callAccountEndpoint('/account/create/finish', {
-            challengeId: start.challengeId,
-            signature: signMachineChallenge(machine.privateKeyPem, start.challenge),
-        });
-        await signInHeadless(this.auth, finish.token);
-        const profile = await this.saveProfile({
-            profile: username,
-            username,
-            uid: finish.uid,
-            network,
-            credentialId: finish.credentialId || machine.credentialId,
-            publicKeyPem: machine.publicKeyPem,
-            privateKeyPem: options.saveCredential === false ? null : machine.privateKeyPem,
-            auth: 'machine',
-            createdAt: Date.now(),
-            hasVault: false,
-        });
-        return {
-            ...this.accountSummary(profile),
-            publicKeyPem: machine.publicKeyPem,
-            privateKeyPem: machine.privateKeyPem,
-        };
-    }
-
-    async loginAccount(options = {}) {
-        const username = cleanOptionalUsername(options.username);
-        const profile = await this.loadProfile(username);
-        const credentialId = options.credentialId || profile.credentialId;
-        const privateKeyPem = options.privateKeyPem || profile.privateKeyPem;
-        if (!credentialId || !privateKeyPem) {
-            throw new Error('machine credential required');
-        }
-        const start = await this.callAccountEndpoint('/account/login/start', { credentialId });
-        const finish = await this.callAccountEndpoint('/account/login/finish', {
-            challengeId: start.challengeId,
-            signature: signMachineChallenge(privateKeyPem, start.challenge),
-        });
-        await signInHeadless(this.auth, finish.token);
-        const next = await this.saveProfile({
-            ...profile,
-            uid: finish.uid || profile.uid,
-            username: finish.username || profile.username,
-            credentialId,
-            lastLoginAt: Date.now(),
-        });
-        return this.accountSummary(next);
-    }
-
-    async addMachineCredential(machine) {
-        const start = await this.callAccountEndpoint('/account/credential/add/start', {
-            publicKeyPem: machine.publicKeyPem,
-        }, { auth: true });
-        const finish = await this.callAccountEndpoint('/account/credential/add/finish', {
-            challengeId: start.challengeId,
-            signature: signMachineChallenge(machine.privateKeyPem, start.challenge),
-        }, { auth: true });
-        return finish;
-    }
-
-    async readUsername(uid, fallback = '') {
-        const peer = await this.cloud.peer.read(uid).catch(() => null);
-        return peer?.username || fallback || '';
-    }
-
-    async createPasskeyAccount(options = {}) {
-        const username = cleanUsername(options.username);
-        const network = String(options.network || this.network).toUpperCase();
-        const flow = await runPasskeyBrowserFlow({
-            mode: 'create',
-            label: options.label || username,
-            webUrl: options.webUrl,
-            timeoutMs: options.timeoutMs,
-            onUrl: options.onPasskeyUrl,
-        });
-        const user = await signInHeadless(this.auth, flow.token);
-        await this.cloud.user.username.get(username);
-
-        const machine = options.credential || createMachineCredential();
-        const credential = machine ? await this.addMachineCredential(machine) : null;
-        const profile = await this.saveProfile({
-            profile: username,
-            username,
-            uid: user.uid,
-            network,
-            credentialId: credential?.credentialId || machine?.credentialId || null,
-            publicKeyPem: machine?.publicKeyPem || null,
-            privateKeyPem: options.saveCredential === false ? null : machine?.privateKeyPem || null,
-            auth: 'passkey',
-            createdAt: Date.now(),
-            hasVault: false,
-        });
-        return {
-            ...this.accountSummary(profile),
-            passkey: true,
-            publicKeyPem: machine?.publicKeyPem || null,
-            privateKeyPem: machine?.privateKeyPem || null,
-        };
-    }
-
-    async loginPasskeyAccount(options = {}) {
-        const requested = cleanOptionalUsername(options.username);
-        const stored = requested ? await this.store.load(requested) : await this.store.load();
-        const flow = await runPasskeyBrowserFlow({
-            mode: 'login',
-            uid: options.uid || stored?.uid,
-            webUrl: options.webUrl,
-            timeoutMs: options.timeoutMs,
-            onUrl: options.onPasskeyUrl,
-        });
-        const user = await signInHeadless(this.auth, flow.token);
-        const username = await this.readUsername(user.uid, stored?.username || requested);
-        const hasSavedCredential = !!(stored?.credentialId && stored?.privateKeyPem);
-        const machine = hasSavedCredential ? null : options.credential || createMachineCredential();
-        const credential = machine ? await this.addMachineCredential(machine) : null;
-        const profile = await this.saveProfile({
-            ...(stored || {}),
-            profile: username || stored?.profile || user.uid,
-            username: username || stored?.username || null,
-            uid: user.uid,
-            network: String(stored?.network || options.network || this.network).toUpperCase(),
-            credentialId: credential?.credentialId || stored?.credentialId || machine?.credentialId || null,
-            publicKeyPem: machine?.publicKeyPem || stored?.publicKeyPem || null,
-            privateKeyPem: options.saveCredential === false ? stored?.privateKeyPem || null : machine?.privateKeyPem || stored?.privateKeyPem || null,
-            auth: 'passkey',
-            lastLoginAt: Date.now(),
-        });
-        return {
-            ...this.accountSummary(profile),
-            passkey: true,
-            publicKeyPem: machine?.publicKeyPem || null,
-            privateKeyPem: machine?.privateKeyPem || null,
-        };
-    }
-
-    async me() {
-        const profile = await this.store.load();
-        if (!profile) {
-            return null;
-        }
-        this.profile = profile;
-        return this.accountSummary(profile);
-    }
-
-    async ensureAuth() {
-        const profile = await this.loadProfile();
-        if (this.auth?.currentUser?.uid === profile.uid) {
-            return profile;
-        }
-        if (profile.auth === 'passkey' && (!profile.credentialId || !profile.privateKeyPem)) {
-            await this.loginPasskeyAccount({ username: profile.profile, saveCredential: false });
-            return this.profile;
-        }
-        await this.loginAccount({ username: profile.profile });
-        return this.profile;
-    }
-
-    async bootSession(masterSeed, registry, profile) {
-        const opened = await openRegistryAccountSession(masterSeed, registry, {
-            SparkWallet,
-            network: profile.network || this.network,
-        });
-        this.session = {
-            ...opened,
-            uid: profile.uid,
-            username: profile.username,
-            profile: profile.profile,
-            network: profile.network || this.network,
-            account: this.accountSummary(profile),
-        };
-        return this.session;
-    }
-
-    async createVault(options = {}) {
-        const profile = await this.ensureAuth();
-        if (options.overwrite !== true && await this.cloud.user.vault.exists(profile.uid)) {
-            throw new Error('vault already exists');
-        }
-
-        const vaultSecret = String(options.secret || process.env.VEYL_VAULT_SECRET || randomSecret()).trim();
-        if (!vaultSecret) {
-            throw new Error('vault secret required');
-        }
-
-        const masterSeed = generateSeed();
-        try {
-            const registrySource = createSecretRegistry();
-            const encrypted = await encryptSeedWithPassword(masterSeed, vaultSecret, {
-                deriveKey: deriveVaultKey,
-                registry: registrySource,
-            });
-            const session = await this.bootSession(masterSeed, encrypted.registry, profile);
-            const vault = packSeedData(encrypted);
-            await this.cloud.user.vault.write(profile.uid, vault);
-            await this.cloud.user.profile.walletpk.write(session.walletPK, { network: profile.network || this.network });
-            await this.cloud.user.profile.chatpk.write(session.chatPK);
-            await this.cloud.user.community.accept(profile.uid).catch(() => {});
-            await this.cloud.user.active.write(profile.uid, true).catch(() => {});
-            const next = await this.saveProfile({
-                ...profile,
-                hasVault: true,
-                vaultSecret: options.saveSecret === false ? null : vaultSecret,
-                walletPK: session.walletPK,
-                chatPK: session.chatPK,
-                vaultCreatedAt: Date.now(),
-            });
-            this.session.account = this.accountSummary(next);
-            return {
-                ...this.accountSummary(next),
-                vaultSecret,
-            };
-        } finally {
-            masterSeed.fill(0);
-        }
-    }
-
-    async unlockVault(options = {}) {
-        const profile = await this.ensureAuth();
-        if (this.session) {
-            return this.accountSummary(profile);
-        }
-        const vaultSecret = String(options.secret || process.env.VEYL_VAULT_SECRET || profile.vaultSecret || '').trim();
-        if (!vaultSecret) {
-            throw new Error('vault secret required');
-        }
-        const vault = await this.cloud.user.vault.read(profile.uid);
-        if (!vault) {
-            throw new Error('vault not found');
-        }
-        const packed = unpackSeedData(vault);
-        const masterSeed = await decryptSeed(packed.ct, packed.salt, packed.iv, vaultSecret, packed.kdf, {
-            deriveKey: deriveVaultKey,
-        });
-        try {
-            const session = await this.bootSession(masterSeed, packed.registry, profile);
-            await this.cloud.user.active.write(profile.uid, true).catch(() => {});
-            const next = await this.saveProfile({
-                ...profile,
-                hasVault: true,
-                vaultSecret: options.saveSecret === false ? profile.vaultSecret || null : profile.vaultSecret || vaultSecret,
-                walletPK: session.walletPK,
-                chatPK: session.chatPK,
-                lastUnlockedAt: Date.now(),
-            });
-            this.session.account = this.accountSummary(next);
-            return this.accountSummary(next);
-        } finally {
-            masterSeed.fill(0);
-        }
-    }
-
-    async lockVault() {
-        const session = this.session;
-        this.session = null;
-        closeAccountSession(session);
-        if (session?.uid) {
-            await this.cloud.user.active.write(session.uid, false).catch(() => {});
-        }
-        return true;
-    }
-
-    async ensureUnlocked() {
-        if (!this.session) {
-            await this.unlockVault();
-        }
-        return this.session;
-    }
-
-    async resolvePeer(peer) {
-        return this.actions.peer.resolve(peer);
-    }
-
-    async listChats(options = {}) {
-        return this.actions.chat.list(options);
-    }
-
-    async chatForPeer(peer, options = {}) {
-        return this.actions.chat.chatForPeer(peer, options);
-    }
-
-    async readChat(peer, options = {}) {
-        return this.actions.chat.read(peer, options);
-    }
-
-    async sendPayload(peer, payload, options = {}) {
-        return this.actions.chat.sendPayload(peer, payload, options);
-    }
-
-    async sendChat(peer, message, options = {}) {
-        return this.actions.chat.send(peer, message, options);
-    }
-
-    async balance(options = {}) {
-        return this.actions.money.balance(options);
-    }
-
-    async sendMoney(peer, sats, options = {}) {
-        return this.actions.money.send(peer, sats, options);
-    }
-
-    async requestMoney(peer, sats, options = {}) {
-        return this.actions.money.request(peer, sats, options);
-    }
-
-    async payRequest(requestId, options = {}) {
-        return this.actions.money.pay(requestId, options);
-    }
-
-    async transactions(options = {}) {
-        return this.actions.money.transactions(options);
-    }
-
-    async listenEvents(options = {}) {
-        return listenAccount(this, options);
-    }
-
-    async close() {
-        await this.lockVault();
-        await signOutHeadless(this.auth).catch(() => {});
-    }
-}
-
-export function createClient(options = {}) {
-    return new VeylHeadlessClient(options);
-}
-
-export async function open(options = {}) {
-    return createClient(options);
-}

package/src/cloud.js

@@ -1,52 +0,0 @@
-import { getApp, getApps, initializeApp } from 'firebase/app';
-import { getAuth, signInWithCustomToken, signOut } from 'firebase/auth';
-import { getFirestore } from 'firebase/firestore';
-import { getFunctions } from 'firebase/functions';
-import { getStorage } from 'firebase/storage';
-import { createFirebaseCloud } from '@veyl/shared/cloud/firebase';
-import { firebaseConfig as defaultFirebaseConfig } from '@veyl/shared/firebaseconfig';
-
-export const DEFAULT_FUNCTION_REGION = 'us-central1';
-
-function firebaseApp(name, config) {
-    const existing = getApps().find((app) => app.name === name);
-    return existing || initializeApp(config, name);
-}
-
-export function headlessFunctionBaseUrl(config = defaultFirebaseConfig, region = DEFAULT_FUNCTION_REGION) {
-    const projectId = config?.projectId;
-    if (!projectId) {
-        throw new Error('firebase project id required');
-    }
-    return `https://${region}-${projectId}.cloudfunctions.net/headless`;
-}
-
-export function createHeadlessCloud(options = {}) {
-    const config = options.firebaseConfig || defaultFirebaseConfig;
-    const region = options.region || DEFAULT_FUNCTION_REGION;
-    const app = firebaseApp(options.appName || 'veyl-headless', config);
-    const auth = getAuth(app);
-    const db = getFirestore(app);
-    const functions = getFunctions(app, region);
-    const storage = getStorage(app);
-    return {
-        app,
-        auth,
-        cloud: createFirebaseCloud({ db, auth, functions, storage }),
-        functionBaseUrl: options.functionBaseUrl || headlessFunctionBaseUrl(config, region),
-    };
-}
-
-export async function signInHeadless(auth, token) {
-    if (!token) {
-        throw new Error('auth token required');
-    }
-    const result = await signInWithCustomToken(auth, token);
-    return result?.user || auth.currentUser || null;
-}
-
-export async function signOutHeadless(auth) {
-    if (auth) {
-        await signOut(auth);
-    }
-}

package/src/index.js

@@ -1,11 +0,0 @@
-export {
-    closeAccountSession,
-    openAccountSessionFromSecrets,
-    openLegacyAccountSession,
-    openRegistryAccountSession,
-} from '@veyl/shared/account/session';
-export * from './client.js';
-export * from './cloud.js';
-export * from './machine.js';
-export * from './passkey.js';
-export * from './storage.js';

package/src/kdf.js

@@ -1,12 +0,0 @@
-import { argon2idAsync } from '@noble/hashes/argon2.js';
-
-export async function deriveVaultKey(password, salt, params = {}) {
-    return argon2idAsync(String(password ?? ''), new Uint8Array(salt), {
-        t: params.t,
-        m: params.m,
-        p: params.p,
-        dkLen: params.dkLen,
-        version: params.version,
-        asyncTick: 10,
-    });
-}

package/src/listen.js

@@ -1,120 +0,0 @@
-import { sleep } from '@veyl/shared/utils/async';
-
-const DEFAULT_INTERVAL_MS = 3000;
-const DEFAULT_CHAT_COUNT = 20;
-const DEFAULT_MESSAGE_COUNT = 10;
-const DEFAULT_TX_COUNT = 50;
-
-function cleanCount(value, fallback) {
-    const count = Math.floor(Number(value));
-    return Number.isFinite(count) && count > 0 ? Math.min(count, 100) : fallback;
-}
-
-function cleanInterval(value) {
-    const interval = Math.floor(Number(value));
-    return Number.isFinite(interval) && interval >= 1000 ? interval : DEFAULT_INTERVAL_MS;
-}
-
-function messageKey(message) {
-    return [
-        message?.chatId || '',
-        message?.id || '',
-        message?.cid || '',
-        message?.type || '',
-        message?.txId || '',
-        message?.ts || '',
-    ].join(':');
-}
-
-function transferKey(tx) {
-    return [
-        tx?.id || '',
-        tx?.status || '',
-        tx?.direction || '',
-        tx?.amountSats || '',
-        tx?.updatedAt || '',
-    ].join(':');
-}
-
-function event(type, data = {}) {
-    return {
-        type,
-        ts: Date.now(),
-        ...data,
-    };
-}
-
-function stopped(signal) {
-    return signal?.aborted === true;
-}
-
-export async function listenAccount(client, options = {}) {
-    const intervalMs = cleanInterval(options.intervalMs || options.interval);
-    const chatCount = cleanCount(options.chatCount || options.chats, DEFAULT_CHAT_COUNT);
-    const messageCount = cleanCount(options.messageCount || options.messages, DEFAULT_MESSAGE_COUNT);
-    const txCount = cleanCount(options.txCount || options.transactions, DEFAULT_TX_COUNT);
-    const includeChats = options.chats !== false;
-    const includeTransactions = options.transactions !== false;
-    const replay = options.replay === true;
-    const emit = typeof options.onEvent === 'function' ? options.onEvent : () => {};
-    const seenMessages = new Set();
-    const seenTransfers = new Map();
-    let initialized = false;
-
-    await client.ensureUnlocked();
-    emit(event('ready', { account: client.accountSummary() }));
-
-    while (!stopped(options.signal)) {
-        try {
-            if (includeChats) {
-                const chats = await client.chat.list({ count: chatCount });
-                for (const chat of chats) {
-                    const peer = chat.peerChatPK || chat.username || chat.id;
-                    if (!peer) {
-                        continue;
-                    }
-                    const page = await client.chat.read(peer, {
-                        count: messageCount,
-                        markRead: false,
-                    });
-                    for (const message of page.messages || []) {
-                        const key = messageKey(message);
-                        if (!key || seenMessages.has(key)) {
-                            continue;
-                        }
-                        seenMessages.add(key);
-                        if (initialized || replay) {
-                            emit(event('message', {
-                                chat: page.chat || chat,
-                                message,
-                            }));
-                        }
-                    }
-                }
-            }
-
-            if (includeTransactions) {
-                const page = await client.money.transactions({ count: txCount });
-                for (const tx of page.transfers || []) {
-                    const key = tx?.id || '';
-                    const value = transferKey(tx);
-                    if (!key || seenTransfers.get(key) === value) {
-                        continue;
-                    }
-                    seenTransfers.set(key, value);
-                    if (initialized || replay) {
-                        emit(event('transaction', { transaction: tx }));
-                    }
-                }
-            }
-
-            initialized = true;
-        } catch (error) {
-            emit(event('error', {
-                message: error?.message || String(error),
-            }));
-        }
-
-        await sleep(intervalMs);
-    }
-}