epistery 1.0.0

package/src/utils/CliWallet.ts

@@ -0,0 +1,334 @@
+import { ethers, Wallet } from 'ethers';
+import { Config } from './Config';
+import { DomainConfig } from './types';
+import fs from 'fs';
+import { join } from 'path';
+
+/**
+ * CliWallet - Manages wallet operations for CLI/bot contexts
+ *
+ * Uses Epistery's domain configuration system:
+ * - Domain configs stored in ~/.epistery/{domain}/config.ini
+ * - Each domain has its own wallet (like server-side)
+ * - Default domain configurable in ~/.epistery/config.ini [cli] section
+ * - Automatic wallet creation on initialize
+ *
+ * This matches the server-side model where each domain has a wallet,
+ * making CLI usage consistent with server architecture.
+ */
+
+export interface KeyExchangeRequest {
+  clientAddress: string;
+  clientPublicKey: string;
+  challenge: string;
+  message: string;
+  signature: string;
+  walletSource: string;
+}
+
+export interface KeyExchangeResponse {
+  serverAddress: string;
+  serverPublicKey: string;
+  services: string[];
+  challenge: string;
+  signature: string;
+  identified: boolean;
+  authenticated?: boolean;
+  profile?: any;
+}
+
+export interface SessionInfo {
+  domain: string;
+  cookie: string;
+  authenticated: boolean;
+  timestamp: string;
+}
+
+export class CliWallet {
+  private config: Config;
+  private domainName: string;
+  private domainConfig: DomainConfig;
+  private wallet: Wallet;
+  public address: string;
+  public publicKey: string;
+
+  private constructor(config: Config, domainName: string, domainConfig: DomainConfig, wallet: Wallet) {
+    this.config = config;
+    this.domainName = domainName.toLowerCase();
+    this.domainConfig = domainConfig;
+    this.wallet = wallet;
+    this.address = wallet.address;
+    this.publicKey = wallet.publicKey;
+  }
+
+  /**
+   * Get the default domain from config.ini [cli] section
+   */
+  static getDefaultDomain(): string {
+    const config = new Config();
+    return (config.data as any).cli?.default_domain || 'localhost';
+  }
+
+  /**
+   * Set the default domain in config.ini [cli] section
+   */
+  static setDefaultDomain(domain: string): void {
+    const config = new Config();
+    if (!(config.data as any).cli) {
+      (config.data as any).cli = {};
+    }
+    (config.data as any).cli.default_domain = domain;
+    config.save();
+  }
+
+  /**
+   * Initialize a new domain with wallet
+   * Creates ~/.epistery/{domain}/config.ini with new wallet
+   */
+  static initialize(domain: string, provider?: { name: string, chainId: number, rpc: string }): CliWallet {
+    const config = new Config();
+
+    // Check if domain already exists
+    config.setPath(`/${domain}`);
+    config.load();
+    if (config.data.wallet) {
+      throw new Error(`Domain '${domain}' already initialized. Use load() to access it.`);
+    }
+
+    // Create new wallet
+    const ethersWallet = ethers.Wallet.createRandom();
+
+    // Get provider from root default, argument, or fallback default
+    config.setPath('/');
+    config.load();
+    const providerConfig = provider || config.data.default?.provider || {
+      chainId: 420420422,
+      name: 'polkadot-hub-testnet',
+      rpc: 'https://testnet-passet-hub-eth-rpc.polkadot.io'
+    };
+
+    // Create domain config
+    config.setPath(`/${domain}`);
+    config.data = {
+      domain: domain,
+      wallet: {
+        address: ethersWallet.address,
+        mnemonic: ethersWallet.mnemonic?.phrase || '',
+        publicKey: ethersWallet.publicKey,
+        privateKey: ethersWallet.privateKey
+      },
+      provider: providerConfig
+    };
+    config.save();
+
+    console.log(`Initialized domain: ${domain}`);
+    console.log(`Address: ${ethersWallet.address}`);
+    console.log(`Provider: ${providerConfig.name}`);
+
+    return new CliWallet(config, domain, config.data, ethersWallet);
+  }
+
+  /**
+   * Load domain wallet from config
+   * Throws if domain doesn't exist - use initialize() first
+   */
+  static load(domain?: string): CliWallet {
+    const config = new Config();
+    const domainName = domain || CliWallet.getDefaultDomain();
+
+    config.setPath(`/${domainName}`);
+    config.load();
+
+    if (!config.data.wallet) {
+      throw new Error(
+        `Domain '${domainName}' not found or has no wallet. ` +
+        `Initialize with: epistery initialize ${domainName}`
+      );
+    }
+
+    // Reconstruct wallet from config
+    let ethersWallet: Wallet;
+    if (config.data.wallet.mnemonic) {
+      ethersWallet = ethers.Wallet.fromMnemonic(config.data.wallet.mnemonic);
+    } else if (config.data.wallet.privateKey) {
+      ethersWallet = new ethers.Wallet(config.data.wallet.privateKey);
+    } else {
+      throw new Error(`Domain '${domainName}' wallet has no mnemonic or privateKey`);
+    }
+
+    return new CliWallet(config, domainName, config.data, ethersWallet);
+  }
+
+  /**
+   * Get domain name
+   */
+  getDomain(): string {
+    return this.domainName;
+  }
+
+  /**
+   * Get provider info
+   */
+  getProvider() {
+    return this.domainConfig.provider;
+  }
+
+  /**
+   * Sign a message
+   */
+  async sign(message: string): Promise<string> {
+    return await this.wallet.signMessage(message);
+  }
+
+  /**
+   * Perform key exchange with an Epistery server
+   * Automatically saves session cookie to domain config
+   */
+  async performKeyExchange(serverUrl: string): Promise<KeyExchangeResponse> {
+    // Ensure server URL is properly formatted
+    const baseUrl = serverUrl.replace(/\/$/, '');
+    const connectUrl = `${baseUrl}/.well-known/epistery/connect`;
+
+    // Generate challenge for key exchange
+    const challenge = ethers.utils.hexlify(ethers.utils.randomBytes(32));
+    const message = `Epistery Key Exchange - ${this.address} - ${challenge}`;
+
+    // Sign the message
+    const signature = await this.sign(message);
+
+    // Prepare key exchange request
+    const requestData: KeyExchangeRequest = {
+      clientAddress: this.address,
+      clientPublicKey: this.publicKey,
+      challenge: challenge,
+      message: message,
+      signature: signature,
+      walletSource: 'server'
+    };
+
+    // Perform key exchange
+    const response = await fetch(connectUrl, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify(requestData)
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`Key exchange failed: ${response.status} - ${errorText}`);
+    }
+
+    const serverResponse = await response.json() as KeyExchangeResponse;
+
+    // Verify server's identity
+    const expectedMessage = `Epistery Server Response - ${serverResponse.serverAddress} - ${serverResponse.challenge}`;
+    const recoveredAddress = ethers.utils.verifyMessage(expectedMessage, serverResponse.signature);
+
+    if (recoveredAddress.toLowerCase() !== serverResponse.serverAddress.toLowerCase()) {
+      throw new Error('Server identity verification failed');
+    }
+
+    // Extract and save session cookie if present
+    const cookies = response.headers.get('set-cookie');
+    if (cookies) {
+      const sessionMatch = cookies.match(/_rhonda_session=([^;]+)/);
+      if (sessionMatch) {
+        const sessionToken = sessionMatch[1];
+
+        // Save session to domain config
+        this.saveSession({
+          domain: serverUrl,
+          cookie: sessionToken,
+          authenticated: serverResponse.authenticated || false,
+          timestamp: new Date().toISOString()
+        });
+      }
+    }
+
+    return serverResponse;
+  }
+
+  /**
+   * Get saved session for a specific server URL
+   */
+  getSession(serverUrl: string): SessionInfo | null {
+    const sessionFile = this.getSessionFilePath(serverUrl);
+    if (!fs.existsSync(sessionFile)) {
+      return null;
+    }
+
+    try {
+      const data = fs.readFileSync(sessionFile, 'utf8');
+      return JSON.parse(data) as SessionInfo;
+    } catch (error) {
+      return null;
+    }
+  }
+
+  /**
+   * Save session info to domain directory, keyed by server URL
+   */
+  private saveSession(session: SessionInfo): void {
+    const sessionFile = this.getSessionFilePath(session.domain);
+    fs.writeFileSync(sessionFile, JSON.stringify(session, null, 2), { mode: 0o600 });
+  }
+
+  /**
+   * Clear saved session for a server URL
+   */
+  clearSession(serverUrl: string): void {
+    const sessionFile = this.getSessionFilePath(serverUrl);
+    if (fs.existsSync(sessionFile)) {
+      fs.unlinkSync(sessionFile);
+    }
+  }
+
+  /**
+   * Get session file path for a server URL
+   * Hashes the server URL to create a safe filename
+   */
+  private getSessionFilePath(serverUrl: string): string {
+    // Create a safe filename from the server URL
+    const crypto = require('crypto');
+    const hash = crypto.createHash('md5').update(serverUrl).digest('hex');
+    const sessionsDir = join(this.config.configDir, this.domainName, 'sessions');
+
+    // Ensure sessions directory exists
+    if (!fs.existsSync(sessionsDir)) {
+      fs.mkdirSync(sessionsDir, { mode: 0o700, recursive: true });
+    }
+
+    return join(sessionsDir, `${hash}.json`);
+  }
+
+  /**
+   * Create bot authentication header
+   * Format: Authorization: Bot <base64-json>
+   */
+  async createBotAuthHeader(): Promise<string> {
+    const message = `Rhonda Bot Authentication - ${new Date().toISOString()}`;
+    const signature = await this.sign(message);
+
+    const payload = {
+      address: this.address,
+      signature,
+      message
+    };
+
+    return `Bot ${Buffer.from(JSON.stringify(payload)).toString('base64')}`;
+  }
+
+  /**
+   * Export wallet data (for migration or backup)
+   */
+  toJSON() {
+    return {
+      domain: this.domainName,
+      address: this.wallet.address,
+      publicKey: this.wallet.publicKey,
+      provider: this.domainConfig.provider
+    };
+  }
+}

package/src/utils/Config.ts

@@ -0,0 +1,196 @@
+import fs from 'fs';
+import { join } from 'path';
+import ini from 'ini';
+
+/**
+ * Epistery Config - Path-based configuration system
+ *
+ * Provides unified, filesystem-like config management:
+ * - setPath('/') → ~/.epistery/config.ini
+ * - setPath('/domain') → ~/.epistery/domain/config.ini
+ * - setPath('/.ssl/domain') → ~/.epistery/.ssl/domain/config.ini
+ *
+ * Usage:
+ *   const config = new Config('epistery');
+ *   config.setPath('/wiki.rootz.global');
+ *   config.load();
+ *   config.data.verified = true;
+ *   config.save();
+ */
+export class Config {
+  public readonly rootName: string;
+  public readonly homeDir: string;
+  public readonly configDir: string;
+
+  private currentPath: string = '/';
+  private currentDir: string;
+  private currentFile: string;
+
+  public data: any = {};
+
+  constructor(rootName: string = 'epistery') {
+    this.rootName = rootName;
+    this.homeDir = (process.platform === 'win32' ? process.env.USERPROFILE : process.env.HOME) || '';
+    this.configDir = join(this.homeDir, '.' + this.rootName);
+
+    this.currentDir = this.configDir;
+    this.currentFile = join(this.configDir, 'config.ini');
+
+    // Initialize root config if it doesn't exist
+    if (!fs.existsSync(this.currentFile)) {
+      this.initialize();
+    }
+  }
+
+  /**
+   * Set current working path (like cd)
+   * Examples: '/', '/domain', '/.ssl/domain'
+   */
+  public setPath(path: string): void {
+    // Normalize path: ensure leading slash, remove trailing slash, lowercase
+    path = path.trim();
+    if (!path.startsWith('/')) path = '/' + path;
+    if (path.length > 1 && path.endsWith('/')) path = path.slice(0, -1);
+    path = path.toLowerCase();
+
+    this.currentPath = path;
+
+    // Calculate directory and file paths
+    if (path === '/') {
+      this.currentDir = this.configDir;
+      this.currentFile = join(this.configDir, 'config.ini');
+    } else {
+      this.currentDir = join(this.configDir, path.slice(1)); // Remove leading /
+      this.currentFile = join(this.currentDir, 'config.ini');
+    }
+  }
+
+  /**
+   * Get current path
+   */
+  public getPath(): string {
+    return this.currentPath;
+  }
+
+  /**
+   * Initialize config at current path
+   */
+  private initialize(): void {
+    if (!fs.existsSync(this.currentDir)) {
+      fs.mkdirSync(this.currentDir, { recursive: true });
+    }
+
+    // Write default config for root, empty for paths
+    const defaultContent = this.currentPath === '/' ? defaultIni : '';
+    fs.writeFileSync(this.currentFile, defaultContent);
+    this.data = ini.decode(defaultContent);
+  }
+
+  /**
+   * Load config from current path
+   */
+  public load(): void {
+    if (!fs.existsSync(this.currentFile)) {
+      this.data = {};
+      return;
+    }
+
+    const fileData = fs.readFileSync(this.currentFile, 'utf8');
+    this.data = ini.decode(fileData);
+  }
+
+  /**
+   * Read config from arbitrary path without changing current path
+   * @param path Path to read from (e.g., '/', '/domain')
+   * @returns Parsed config data from that path
+   */
+  public read(path: string): any {
+    // Normalize path
+    path = path.trim();
+    if (!path.startsWith('/')) path = '/' + path;
+    if (path.length > 1 && path.endsWith('/')) path = path.slice(0, -1);
+    path = path.toLowerCase();
+
+    // Calculate file location
+    let configFile: string;
+    if (path === '/') {
+      configFile = join(this.configDir, 'config.ini');
+    } else {
+      configFile = join(this.configDir, path.slice(1), 'config.ini');
+    }
+
+    // Read and parse
+    if (!fs.existsSync(configFile)) {
+      return {};
+    }
+
+    const fileData = fs.readFileSync(configFile, 'utf8');
+    return ini.decode(fileData);
+  }
+
+  /**
+   * Save config to current path
+   */
+  public save(): void {
+    if (!fs.existsSync(this.currentDir)) {
+      fs.mkdirSync(this.currentDir, { recursive: true });
+    }
+
+    const text = ini.stringify(this.data);
+    fs.writeFileSync(this.currentFile, text);
+  }
+
+  /**
+   * Read file from current path directory
+   */
+  public readFile(filename: string): Buffer {
+    return fs.readFileSync(join(this.currentDir, filename));
+  }
+
+  /**
+   * Write file to current path directory
+   */
+  public writeFile(filename: string, data: string | Buffer): void {
+    if (!fs.existsSync(this.currentDir)) {
+      fs.mkdirSync(this.currentDir, { recursive: true });
+    }
+    fs.writeFileSync(join(this.currentDir, filename), data);
+  }
+
+  /**
+   * Check if config exists at current path
+   */
+  public exists(): boolean {
+    return fs.existsSync(this.currentFile);
+  }
+
+  /**
+   * List all subdirectories at current path
+   */
+  public listPaths(): string[] {
+    if (!fs.existsSync(this.currentDir)) {
+      return [];
+    }
+
+    return fs.readdirSync(this.currentDir, { withFileTypes: true })
+      .filter(dirent => dirent.isDirectory())
+      .map(dirent => dirent.name);
+  }
+}
+
+const defaultIni =
+`[profile]
+name=
+email=
+
+[ipfs]
+url=https://rootz.digital/api/v0
+
+[default.provider]
+chainId=1,
+name=Ethereum Mainnet
+rpc=https://eth.llamarpc.com
+nativeCurrencyName=Ether
+nativeCurrencySymbol=ETH
+nativeCurrencyDecimals=18
+`