@glyphteck/veyl 0.1.0 → 0.1.1

package/src/machine.js

@@ -1,38 +0,0 @@
-import { Buffer } from 'node:buffer';
-import { createHash, createPrivateKey, generateKeyPairSync, sign } from 'node:crypto';
-
-const SIGNATURE_CONTEXT = 'veyl-machine-auth-v1\n';
-
-function challengeMessage(challenge) {
-    const value = String(challenge ?? '').trim();
-    if (!value) {
-        throw new Error('challenge required');
-    }
-    return Buffer.from(`${SIGNATURE_CONTEXT}${value}`, 'utf8');
-}
-
-export function credentialIdForPublicKey(publicKeyPem) {
-    const key = String(publicKeyPem ?? '').trim();
-    if (!key) {
-        throw new Error('machine public key required');
-    }
-    return createHash('sha256').update(key).digest('base64url');
-}
-
-export function createMachineCredential() {
-    const { privateKey, publicKey } = generateKeyPairSync('ed25519');
-    const publicKeyPem = publicKey.export({ type: 'spki', format: 'pem' });
-    const privateKeyPem = privateKey.export({ type: 'pkcs8', format: 'pem' });
-    const credentialId = credentialIdForPublicKey(publicKeyPem);
-    return {
-        type: 'ed25519',
-        credentialId,
-        publicKeyPem,
-        privateKeyPem,
-    };
-}
-
-export function signMachineChallenge(privateKeyPem, challenge) {
-    const key = createPrivateKey(String(privateKeyPem ?? ''));
-    return sign(null, challengeMessage(challenge), key).toString('base64url');
-}

package/src/mcp.js

@@ -1,96 +0,0 @@
-import { createInterface } from 'node:readline';
-import process from 'node:process';
-
-const TOOLS = [
-    { name: 'account_create', description: 'Create a Veyl account headlessly.', inputSchema: { type: 'object', properties: { username: { type: 'string' }, network: { type: 'string' } }, required: ['username'] } },
-    { name: 'account_login', description: 'Log in with the local machine credential.', inputSchema: { type: 'object', properties: { username: { type: 'string' } } } },
-    { name: 'account_me', description: 'Show the current local account.', inputSchema: { type: 'object', properties: {} } },
-    { name: 'vault_create', description: 'Create and upload the local encrypted vault.', inputSchema: { type: 'object', properties: { secret: { type: 'string' }, saveSecret: { type: 'boolean' } } } },
-    { name: 'vault_unlock', description: 'Unlock the local encrypted vault.', inputSchema: { type: 'object', properties: { secret: { type: 'string' } } } },
-    { name: 'vault_lock', description: 'Lock the wallet and chat session.', inputSchema: { type: 'object', properties: {} } },
-    { name: 'chat_list', description: 'List chats.', inputSchema: { type: 'object', properties: { count: { type: 'number' } } } },
-    { name: 'chat_read', description: 'Read display messages from a chat.', inputSchema: { type: 'object', properties: { peer: { type: 'string' }, count: { type: 'number' } }, required: ['peer'] } },
-    { name: 'chat_send', description: 'Send a text message.', inputSchema: { type: 'object', properties: { peer: { type: 'string' }, message: { type: 'string' } }, required: ['peer', 'message'] } },
-    { name: 'money_balance', description: 'Read wallet balance.', inputSchema: { type: 'object', properties: {} } },
-    { name: 'money_send', description: 'Send sats to a peer.', inputSchema: { type: 'object', properties: { peer: { type: 'string' }, sats: { type: 'number' } }, required: ['peer', 'sats'] } },
-    { name: 'money_request', description: 'Request sats from a peer.', inputSchema: { type: 'object', properties: { peer: { type: 'string' }, sats: { type: 'number' } }, required: ['peer', 'sats'] } },
-    { name: 'money_pay', description: 'Pay a chat payment request.', inputSchema: { type: 'object', properties: { requestId: { type: 'string' } }, required: ['requestId'] } },
-    { name: 'transactions_list', description: 'List wallet transactions.', inputSchema: { type: 'object', properties: { count: { type: 'number' }, offset: { type: 'number' } } } },
-];
-
-function result(value) {
-    return {
-        content: [
-            {
-                type: 'text',
-                text: JSON.stringify(value ?? null, null, 2),
-            },
-        ],
-    };
-}
-
-async function callTool(client, name, args = {}) {
-    if (name === 'account_create') return client.account.create(args);
-    if (name === 'account_login') return client.account.login(args);
-    if (name === 'account_me') return client.account.me();
-    if (name === 'vault_create') return client.vault.create(args);
-    if (name === 'vault_unlock') return client.vault.unlock(args);
-    if (name === 'vault_lock') return client.vault.lock(args);
-    if (name === 'chat_list') return client.chat.list(args);
-    if (name === 'chat_read') return client.chat.read(args.peer, args);
-    if (name === 'chat_send') return client.chat.send(args.peer, args.message, args);
-    if (name === 'money_balance') return client.money.balance(args);
-    if (name === 'money_send') return client.money.send(args.peer, args.sats, args);
-    if (name === 'money_request') return client.money.request(args.peer, args.sats, args);
-    if (name === 'money_pay') return client.money.pay(args.requestId, args);
-    if (name === 'transactions_list') return client.money.transactions(args);
-    throw new Error(`unknown tool ${name}`);
-}
-
-function write(message) {
-    process.stdout.write(`${JSON.stringify(message)}\n`);
-}
-
-function writeError(id, error) {
-    write({
-        jsonrpc: '2.0',
-        id,
-        error: {
-            code: -32000,
-            message: error?.message || String(error),
-        },
-    });
-}
-
-export async function serveMcp(client) {
-    const rl = createInterface({ input: process.stdin, crlfDelay: Infinity });
-    for await (const line of rl) {
-        if (!line.trim()) {
-            continue;
-        }
-        let message = null;
-        try {
-            message = JSON.parse(line);
-            if (message.method === 'initialize') {
-                write({
-                    jsonrpc: '2.0',
-                    id: message.id,
-                    result: {
-                        protocolVersion: '2024-11-05',
-                        capabilities: { tools: {} },
-                        serverInfo: { name: 'veyl', version: '0.1.0' },
-                    },
-                });
-            } else if (message.method === 'tools/list') {
-                write({ jsonrpc: '2.0', id: message.id, result: { tools: TOOLS } });
-            } else if (message.method === 'tools/call') {
-                const toolResult = await callTool(client, message.params?.name, message.params?.arguments || {});
-                write({ jsonrpc: '2.0', id: message.id, result: result(toolResult) });
-            } else if (message.id != null) {
-                write({ jsonrpc: '2.0', id: message.id, result: {} });
-            }
-        } catch (error) {
-            writeError(message?.id ?? null, error);
-        }
-    }
-}

package/src/passkey.js

@@ -1,182 +0,0 @@
-import { spawn } from 'node:child_process';
-import { randomBytes } from 'node:crypto';
-import http from 'node:http';
-import process from 'node:process';
-import { links } from '@veyl/shared/links';
-
-const CALLBACK_PATH = '/callback';
-const DEFAULT_TIMEOUT_MS = 120_000;
-
-function cleanMode(value) {
-    const mode = String(value || '').trim().toLowerCase();
-    if (mode === 'create' || mode === 'login') {
-        return mode;
-    }
-    throw new Error('passkey mode must be create or login');
-}
-
-function cleanWebUrl(value) {
-    const source = String(value || process.env.VEYL_WEB_URL || links.veyl).trim();
-    const url = new URL(source);
-    if (url.protocol !== 'https:' && url.hostname !== 'localhost') {
-        throw new Error('passkey web url must be https or localhost');
-    }
-    return url;
-}
-
-function appendSearch(url, params) {
-    Object.entries(params).forEach(([key, value]) => {
-        const text = String(value || '').trim();
-        if (text) {
-            url.searchParams.set(key, text);
-        }
-    });
-    return url;
-}
-
-function openBrowser(url) {
-    const target = String(url);
-    const command =
-        process.platform === 'darwin' ? 'open' :
-            process.platform === 'win32' ? 'cmd' :
-                'xdg-open';
-    const args =
-        process.platform === 'win32' ? ['/c', 'start', '', target] :
-            [target];
-
-    const child = spawn(command, args, {
-        detached: true,
-        stdio: 'ignore',
-    });
-    child.unref();
-}
-
-function setCors(res) {
-    res.setHeader('Access-Control-Allow-Origin', '*');
-    res.setHeader('Access-Control-Allow-Methods', 'POST, OPTIONS');
-    res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
-    res.setHeader('Access-Control-Allow-Private-Network', 'true');
-}
-
-function readBody(req) {
-    return new Promise((resolve, reject) => {
-        let body = '';
-        req.setEncoding('utf8');
-        req.on('data', (chunk) => {
-            body += chunk;
-            if (body.length > 32_768) {
-                reject(new Error('passkey callback body too large'));
-                req.destroy();
-            }
-        });
-        req.on('end', () => {
-            try {
-                resolve(body ? JSON.parse(body) : {});
-            } catch {
-                reject(new Error('passkey callback body must be json'));
-            }
-        });
-        req.on('error', reject);
-    });
-}
-
-function listen(server) {
-    return new Promise((resolve, reject) => {
-        server.once('error', reject);
-        server.listen(0, '127.0.0.1', () => {
-            server.off('error', reject);
-            resolve(server.address());
-        });
-    });
-}
-
-export async function runPasskeyBrowserFlow(options = {}) {
-    const mode = cleanMode(options.mode);
-    const state = randomBytes(24).toString('base64url');
-    const timeoutMs = Math.max(10_000, Number(options.timeoutMs || DEFAULT_TIMEOUT_MS));
-
-    let settled = false;
-    let timer = null;
-    let server = null;
-
-    function close() {
-        if (timer) {
-            clearTimeout(timer);
-            timer = null;
-        }
-        server?.close?.();
-    }
-
-    const result = new Promise((resolve, reject) => {
-        server = http.createServer(async (req, res) => {
-            setCors(res);
-            if (req.method === 'OPTIONS') {
-                res.writeHead(204).end();
-                return;
-            }
-            if (req.method !== 'POST' || new URL(req.url || '/', 'http://127.0.0.1').pathname !== CALLBACK_PATH) {
-                res.writeHead(404, { 'Content-Type': 'application/json' }).end(JSON.stringify({ ok: false }));
-                return;
-            }
-            try {
-                const body = await readBody(req);
-                if (body.state !== state) {
-                    res.writeHead(403, { 'Content-Type': 'application/json' }).end(JSON.stringify({ ok: false }));
-                    return;
-                }
-                if (body.ok === false) {
-                    throw new Error(body.message || 'passkey flow failed');
-                }
-                if (!body.token) {
-                    throw new Error('passkey token missing');
-                }
-                settled = true;
-                res.writeHead(200, { 'Content-Type': 'application/json' }).end(JSON.stringify({ ok: true }));
-                close();
-                resolve({
-                    mode,
-                    token: body.token,
-                    uid: body.uid || null,
-                });
-            } catch (error) {
-                settled = true;
-                res.writeHead(400, { 'Content-Type': 'application/json' }).end(JSON.stringify({ ok: false }));
-                close();
-                reject(error);
-            }
-        });
-
-        timer = setTimeout(() => {
-            if (settled) return;
-            settled = true;
-            close();
-            reject(new Error('passkey flow timed out'));
-        }, timeoutMs);
-    });
-
-    let address;
-    try {
-        address = await listen(server);
-    } catch (error) {
-        close();
-        throw error;
-    }
-    const callback = `http://127.0.0.1:${address.port}${CALLBACK_PATH}`;
-    const target = appendSearch(new URL('/cli/passkey', cleanWebUrl(options.webUrl)), {
-        mode,
-        state,
-        callback,
-        label: options.label,
-        uid: options.uid,
-    });
-
-    options.onUrl?.(String(target));
-    try {
-        openBrowser(target);
-    } catch (error) {
-        close();
-        throw error;
-    }
-
-    return result;
-}

package/src/storage.js

@@ -1,113 +0,0 @@
-import { access, chmod, mkdir, readFile, rename, writeFile } from 'node:fs/promises';
-import { homedir } from 'node:os';
-import { dirname, join } from 'node:path';
-import process from 'node:process';
-
-const FILE_MODE = 0o600;
-const DIR_MODE = 0o700;
-
-function trimAt(value) {
-    return String(value ?? '').trim().replace(/^@+/, '');
-}
-
-export function cleanProfileName(value, fallback = '') {
-    const clean = trimAt(value)
-        .toLowerCase()
-        .replace(/[^a-z0-9._-]+/g, '-')
-        .replace(/^-+|-+$/g, '');
-    return clean || fallback;
-}
-
-export function defaultHomeDir() {
-    return process.env.VEYL_HOME || join(homedir(), '.veyl');
-}
-
-async function exists(path) {
-    try {
-        await access(path);
-        return true;
-    } catch {
-        return false;
-    }
-}
-
-async function readJson(path, fallback = null) {
-    if (!(await exists(path))) {
-        return fallback;
-    }
-    return JSON.parse(await readFile(path, 'utf8'));
-}
-
-async function writeJson(path, value) {
-    await mkdir(dirname(path), { recursive: true, mode: DIR_MODE });
-    const tmp = `${path}.${process.pid}.${Date.now()}.tmp`;
-    await writeFile(tmp, `${JSON.stringify(value, null, 2)}\n`, { mode: FILE_MODE });
-    await chmod(tmp, FILE_MODE).catch(() => {});
-    await rename(tmp, path);
-    await chmod(path, FILE_MODE).catch(() => {});
-}
-
-export class ProfileStore {
-    constructor(options = {}) {
-        this.dir = options.dir || defaultHomeDir();
-        this.profile = cleanProfileName(options.profile || process.env.VEYL_PROFILE || '', '');
-    }
-
-    activePath() {
-        return join(this.dir, 'active.json');
-    }
-
-    profilePath(profileName) {
-        const profile = cleanProfileName(profileName, '');
-        if (!profile) {
-            throw new Error('profile required');
-        }
-        return join(this.dir, 'profiles', `${profile}.json`);
-    }
-
-    async readActiveProfile() {
-        const active = await readJson(this.activePath(), null);
-        return cleanProfileName(this.profile || active?.profile || '', '');
-    }
-
-    async writeActiveProfile(profileName) {
-        const profile = cleanProfileName(profileName, '');
-        if (!profile) {
-            throw new Error('profile required');
-        }
-        await writeJson(this.activePath(), { profile, updatedAt: Date.now() });
-        return profile;
-    }
-
-    async load(profileName = '') {
-        const profile = cleanProfileName(profileName || this.profile || await this.readActiveProfile(), '');
-        if (!profile) {
-            return null;
-        }
-        const data = await readJson(this.profilePath(profile), null);
-        return data ? { ...data, profile } : null;
-    }
-
-    async require(profileName = '') {
-        const profile = await this.load(profileName);
-        if (!profile) {
-            throw new Error('account profile not found. run account.create or account.login first');
-        }
-        return profile;
-    }
-
-    async save(profile) {
-        const profileName = cleanProfileName(profile?.profile || profile?.username, '');
-        if (!profileName) {
-            throw new Error('profile required');
-        }
-        const next = {
-            ...profile,
-            profile: profileName,
-            updatedAt: Date.now(),
-        };
-        await writeJson(this.profilePath(profileName), next);
-        await this.writeActiveProfile(profileName);
-        return next;
-    }
-}