lattice-install 0.1.0

package/bin/lattice-install.js

@@ -0,0 +1,491 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const readline = require('readline');
+const https = require('https');
+const { execSync } = require('child_process');
+
+// ─── Constants ───────────────────────────────────────────────────────────────
+
+const LATTICE_BASE_URL = 'https://latticeproxy.io';
+const LATTICE_PROXY_URL = `${LATTICE_BASE_URL}/v1`;
+const REPORT_URL = `${LATTICE_BASE_URL}/install/report`;
+const DOCS_URL = `${LATTICE_BASE_URL}/docs`;
+
+const HOME = os.homedir();
+
+const PATHS = {
+  openclaw:  path.join(HOME, '.openclaw', 'openclaw.json'),
+  continue:  path.join(HOME, '.continue', 'config.json'),
+  aider:     path.join(HOME, '.config', 'aider', 'config.yml'),
+  cursor:    path.join(HOME, '.cursor', 'config.json'),
+  envFile:   path.join(process.cwd(), '.env'),
+  bashrc:    path.join(HOME, '.bashrc'),
+  zshrc:     path.join(HOME, '.zshrc'),
+};
+
+// ─── Help ─────────────────────────────────────────────────────────────────────
+
+if (process.argv.includes('--help') || process.argv.includes('-h')) {
+  console.log(`
+lattice-install — Onboard to Lattice Network in 60 seconds
+
+USAGE
+  lattice-install [options]
+
+OPTIONS
+  --help, -h    Show this help message
+
+WHAT IT DOES
+  1. Detects installed AI coding tools (OpenClaw, Continue, Cursor, Aider)
+  2. Asks which AI provider you use (Anthropic default)
+  3. Collects your API key
+  4. Configures OpenClaw to route through Lattice proxy
+  5. Adds ANTHROPIC_BASE_URL / OPENAI_BASE_URL to your shell profile
+  6. Tests the connection
+  7. Reports telemetry to latticeproxy.io (fire-and-forget)
+
+SUPPORTED TOOLS
+  ✓ OpenClaw     — config written automatically
+  ✓ Shell profile (.bashrc / .zshrc) — env var written automatically
+  ⚠ Continue     — detected, manual config required
+  ⚠ Cursor       — detected, manual config required
+  ⚠ Aider        — detected, manual config required
+
+DOCS
+  ${DOCS_URL}
+`);
+  process.exit(0);
+}
+
+// ─── Utilities ────────────────────────────────────────────────────────────────
+
+function atomicWrite(filePath, content) {
+  const dir = path.dirname(filePath);
+  const tmp = path.join(dir, `.lattice-tmp-${process.pid}-${Date.now()}`);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(tmp, content, { encoding: 'utf8', mode: 0o600 });
+  fs.renameSync(tmp, filePath);
+}
+
+function readJsonSafe(filePath) {
+  try {
+    const raw = fs.readFileSync(filePath, 'utf8');
+    return JSON.parse(raw);
+  } catch (e) {
+    if (e.code === 'ENOENT') return null;
+    if (e instanceof SyntaxError) {
+      console.error(`  ⚠ Could not parse ${filePath}: ${e.message}`);
+      return null;
+    }
+    throw e;
+  }
+}
+
+function fileExists(p) {
+  try { fs.accessSync(p); return true; } catch { return false; }
+}
+
+function ask(rl, question) {
+  return new Promise(resolve => rl.question(question, resolve));
+}
+
+function spin(label) {
+  const frames = ['⠋','⠙','⠹','⠸','⠼','⠴','⠦','⠧','⠇','⠏'];
+  let i = 0;
+  const id = setInterval(() => {
+    process.stdout.write(`\r${frames[i++ % frames.length]}  ${label}`);
+  }, 80);
+  return {
+    stop(result) {
+      clearInterval(id);
+      process.stdout.write(`\r${result}\n`);
+    }
+  };
+}
+
+function httpsGet(url, timeoutMs = 8000) {
+  return new Promise((resolve, reject) => {
+    const req = https.get(url, { timeout: timeoutMs }, res => {
+      let body = '';
+      res.on('data', d => body += d);
+      res.on('end', () => resolve({ status: res.statusCode, body }));
+    });
+    req.on('timeout', () => { req.destroy(); reject(new Error('timeout')); });
+    req.on('error', reject);
+  });
+}
+
+function httpsPost(url, payload, timeoutMs = 6000) {
+  return new Promise((resolve, reject) => {
+    const data = JSON.stringify(payload);
+    const u = new URL(url);
+    const options = {
+      hostname: u.hostname,
+      port: u.port || 443,
+      path: u.pathname,
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(data),
+        'User-Agent': 'lattice-install/0.1.0',
+      },
+      timeout: timeoutMs,
+    };
+    const req = https.request(options, res => {
+      let body = '';
+      res.on('data', d => body += d);
+      res.on('end', () => resolve({ status: res.statusCode, body }));
+    });
+    req.on('timeout', () => { req.destroy(); reject(new Error('timeout')); });
+    req.on('error', reject);
+    req.write(data);
+    req.end();
+  });
+}
+
+// ─── Detection ────────────────────────────────────────────────────────────────
+
+function detectTools() {
+  const found = {
+    openclaw: false,
+    continue: false,
+    aider: false,
+    cursor: false,
+    hasEnvFile: false,
+    hasShellProfile: [],
+    existingKeys: [],
+  };
+
+  found.openclaw  = fileExists(PATHS.openclaw);
+  found.continue  = fileExists(PATHS.continue);
+  found.aider     = fileExists(PATHS.aider);
+  found.cursor    = fileExists(PATHS.cursor);
+  found.hasEnvFile = fileExists(PATHS.envFile);
+
+  if (fileExists(PATHS.bashrc)) found.hasShellProfile.push('.bashrc');
+  if (fileExists(PATHS.zshrc))  found.hasShellProfile.push('.zshrc');
+
+  // Sniff for existing keys in env/shell files
+  const sniffPaths = [PATHS.envFile, PATHS.bashrc, PATHS.zshrc];
+  for (const p of sniffPaths) {
+    if (!fileExists(p)) continue;
+    try {
+      const content = fs.readFileSync(p, 'utf8');
+      if (/ANTHROPIC_API_KEY\s*=\s*sk-ant-/.test(content)) {
+        const m = content.match(/ANTHROPIC_API_KEY\s*=\s*(sk-ant-[^\s"']+)/);
+        if (m) found.existingKeys.push({ provider: 'anthropic', key: m[1], source: p });
+      }
+      if (/OPENAI_API_KEY\s*=\s*sk-/.test(content)) {
+        const m = content.match(/OPENAI_API_KEY\s*=\s*(sk-[^\s"']+)/);
+        if (m) found.existingKeys.push({ provider: 'openai', key: m[1], source: p });
+      }
+    } catch { /* ignore read errors */ }
+  }
+
+  return found;
+}
+
+// ─── Configure OpenClaw ───────────────────────────────────────────────────────
+
+function configureOpenclaw(apiKey) {
+  let config = readJsonSafe(PATHS.openclaw) || {};
+
+  // Ensure nested structure exists
+  config.models = config.models || {};
+  config.models.providers = config.models.providers || {};
+  config.agents = config.agents || {};
+  config.agents.defaults = config.agents.defaults || {};
+  config.agents.defaults.model = config.agents.defaults.model || {};
+
+  // Set lattice provider
+  config.models.providers.lattice = {
+    baseUrl: 'https://latticeproxy.io/v1',
+    apiKey: apiKey,
+    api: 'openai-completions',
+    models: [
+      { id: 'lattice-sonnet', name: 'Claude Sonnet (via Lattice)', api: 'openai-completions', contextWindow: 200000, maxTokens: 16000 },
+      { id: 'lattice-opus',   name: 'Claude Opus (via Lattice)',   api: 'openai-completions', contextWindow: 200000, maxTokens: 32000 },
+      { id: 'lattice-haiku',  name: 'Claude Haiku (via Lattice)',  api: 'openai-completions', contextWindow: 200000, maxTokens: 8000  },
+    ],
+  };
+
+  // Set default model
+  config.agents.defaults.model.primary = 'lattice/lattice-sonnet';
+
+  atomicWrite(PATHS.openclaw, JSON.stringify(config, null, 2) + '\n');
+}
+
+// ─── Configure shell profile ──────────────────────────────────────────────────
+
+function appendShellExport(profilePath, lines) {
+  const marker = '# Added by lattice-install';
+  let existing = '';
+  try { existing = fs.readFileSync(profilePath, 'utf8'); } catch { /* new file */ }
+
+  if (existing.includes(marker)) {
+    // Replace the block
+    const block = `${marker}\n${lines.join('\n')}\n# End lattice-install\n`;
+    const replaced = existing.replace(
+      /# Added by lattice-install[\s\S]*?# End lattice-install\n?/,
+      block,
+    );
+    atomicWrite(profilePath, replaced);
+  } else {
+    const block = `\n${marker}\n${lines.join('\n')}\n# End lattice-install\n`;
+    atomicWrite(profilePath, existing + block);
+  }
+}
+
+function configureShellProfiles(apiKey, provider, proxyUrl, profiles) {
+  const lines = provider === 'anthropic'
+    ? [
+        `export ANTHROPIC_API_KEY="${apiKey}"`,
+        `export ANTHROPIC_BASE_URL="${proxyUrl}"`,
+      ]
+    : [
+        `export OPENAI_API_KEY="${apiKey}"`,
+        `export OPENAI_BASE_URL="${proxyUrl}"`,
+      ];
+
+  for (const profile of profiles) {
+    const fullPath = profile === '.bashrc' ? PATHS.bashrc : PATHS.zshrc;
+    try {
+      appendShellExport(fullPath, lines);
+    } catch (e) {
+      if (e.code === 'EACCES') {
+        console.error(`  ⚠ Permission denied writing to ~/${profile} — skipping`);
+      } else {
+        throw e;
+      }
+    }
+  }
+}
+
+// ─── Test connection ──────────────────────────────────────────────────────────
+
+async function testConnection(apiKey, provider, proxyUrl) {
+  const spinner = spin('Testing connection to Lattice proxy…');
+  try {
+    // Hit the proxy health/models endpoint
+    const testUrl = `${proxyUrl}/models`;
+    const u = new URL(testUrl);
+    const options = {
+      hostname: u.hostname,
+      port: u.port || 443,
+      path: u.pathname,
+      method: 'GET',
+      headers: {
+        'Authorization': `Bearer ${apiKey}`,
+        'User-Agent': 'lattice-install/0.1.0',
+      },
+      timeout: 10000,
+    };
+    const result = await new Promise((resolve, reject) => {
+      const req = https.request(options, res => {
+        let body = '';
+        res.on('data', d => body += d);
+        res.on('end', () => resolve({ status: res.statusCode, body }));
+      });
+      req.on('timeout', () => { req.destroy(); reject(new Error('timeout')); });
+      req.on('error', reject);
+      req.end();
+    });
+    // Accept 200 or 401 (proxy reachable, auth may vary)
+    if (result.status < 500) {
+      spinner.stop('✓  Connection successful');
+      return true;
+    } else {
+      spinner.stop(`⚠  Proxy returned HTTP ${result.status} — check your key`);
+      return false;
+    }
+  } catch (e) {
+    spinner.stop(`⚠  Could not reach ${proxyUrl} (${e.message}) — check network`);
+    return false;
+  }
+}
+
+// ─── Report telemetry ─────────────────────────────────────────────────────────
+
+function fireAndForgetReport(payload) {
+  httpsPost(REPORT_URL, payload, 6000).catch(() => { /* silently ignore */ });
+}
+
+// ─── Main ─────────────────────────────────────────────────────────────────────
+
+async function main() {
+  // Step 1: Banner
+  console.log(`
+╔══════════════════════════════════════════════════════╗
+║          Lattice Network — Install & Onboard         ║
+║     Route your AI traffic through BFT consensus      ║
+╚══════════════════════════════════════════════════════╝
+`);
+
+  // Step 2: Detect tools
+  console.log('Scanning for AI tools…\n');
+  const detected = detectTools();
+
+  const detectedList = [];
+  if (detected.openclaw)  detectedList.push('OpenClaw');
+  if (detected.continue)  detectedList.push('Continue');
+  if (detected.cursor)    detectedList.push('Cursor');
+  if (detected.aider)     detectedList.push('Aider');
+  if (detected.hasShellProfile.length) detectedList.push(`shell (${detected.hasShellProfile.join(', ')})`);
+
+  if (detectedList.length) {
+    console.log('  Detected: ' + detectedList.join(', '));
+  } else {
+    console.log('  No known AI tools detected — will configure shell profile');
+  }
+
+  // Warn about Option-A tools
+  const optionATools = [];
+  if (detected.continue) {
+    console.log(`\n  ⚠ Continue detected — manual config needed, see ${DOCS_URL}`);
+    optionATools.push('continue');
+  }
+  if (detected.cursor) {
+    console.log(`\n  ⚠ Cursor detected — manual config needed, see ${DOCS_URL}`);
+    optionATools.push('cursor');
+  }
+  if (detected.aider) {
+    console.log(`\n  ⚠ Aider detected — manual config needed, see ${DOCS_URL}`);
+    optionATools.push('aider');
+  }
+
+  console.log('');
+
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+
+  try {
+    // Step 3: Ask provider
+    const providerAnswer = await ask(rl,
+      'Which AI provider? [1] Anthropic (default)  [2] OpenAI\n> '
+    );
+    const provider = providerAnswer.trim() === '2' ? 'openai' : 'anthropic';
+    const keyPrefix = provider === 'anthropic' ? 'sk-ant-' : 'sk-';
+    const keyHint   = provider === 'anthropic' ? 'sk-ant-…' : 'sk-…';
+    const envVar    = provider === 'anthropic' ? 'ANTHROPIC_API_KEY' : 'OPENAI_API_KEY';
+    const baseEnvVar = provider === 'anthropic' ? 'ANTHROPIC_BASE_URL' : 'OPENAI_BASE_URL';
+    const proxyUrl  = LATTICE_PROXY_URL;
+
+    console.log(`\n  Provider: ${provider === 'anthropic' ? 'Anthropic' : 'OpenAI'}`);
+
+    // Step 4: Ask for API key
+    let apiKey = '';
+    while (true) {
+      apiKey = (await ask(rl, `\nEnter your ${envVar} (${keyHint}):\n> `)).trim();
+
+      if (!apiKey) {
+        console.log('  API key cannot be empty.');
+        continue;
+      }
+      // Validate format
+      if (provider === 'anthropic' && !apiKey.startsWith('sk-ant-')) {
+        console.log('  Invalid key format. Anthropic keys start with sk-ant-');
+        continue;
+      }
+      if (provider === 'openai' && !apiKey.startsWith('sk-')) {
+        console.log('  Invalid key format. OpenAI keys start with sk-');
+        continue;
+      }
+      break;
+    }
+
+    rl.close();
+
+    // Step 5: Write config
+    console.log('\nConfiguring…\n');
+
+    if (detected.openclaw) {
+      try {
+        configureOpenclaw(apiKey);
+        console.log('  ✓ OpenClaw configured');
+      } catch (e) {
+        if (e.code === 'EACCES') {
+          console.error(`  ⚠ Permission denied writing OpenClaw config — skipping`);
+        } else {
+          throw e;
+        }
+      }
+    }
+
+    // Always write shell profile if any exist; if none found, create .bashrc
+    const profiles = detected.hasShellProfile.length
+      ? detected.hasShellProfile
+      : ['.bashrc'];
+
+    try {
+      configureShellProfiles(apiKey, provider, proxyUrl, profiles);
+      console.log(`  ✓ Shell profile updated (${profiles.join(', ')})`);
+      console.log(`    Added: ${envVar}, ${baseEnvVar}`);
+    } catch (e) {
+      if (e.code === 'EACCES') {
+        console.error('  ⚠ Permission denied writing shell profile');
+      } else {
+        throw e;
+      }
+    }
+
+    // Step 6: Test connection
+    console.log('');
+    const connected = await testConnection(apiKey, provider, proxyUrl);
+
+    // Step 7: Fire-and-forget telemetry report
+    const reportPayload = {
+      version: '0.1.0',
+      provider,
+      tools: {
+        openclaw: detected.openclaw,
+        continue: detected.continue,
+        cursor: detected.cursor,
+        aider: detected.aider,
+        shellProfiles: detected.hasShellProfile,
+        unknown: optionATools,
+      },
+      connected,
+      platform: process.platform,
+      nodeVersion: process.version,
+      timestamp: new Date().toISOString(),
+    };
+    fireAndForgetReport(reportPayload);
+
+    // Step 8: Success message
+    console.log(`
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  ✓ Lattice Network configured!
+
+  Your AI requests now route through Lattice's BFT
+  consensus network for verifiable, auditable inference.
+
+  Reload your shell to apply profile changes:
+    source ~/${profiles[0]}
+
+  Docs & dashboard: ${LATTICE_BASE_URL}
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+`);
+
+    process.exit(0);
+
+  } catch (e) {
+    rl.close();
+    if (e.code === 'ERR_USE_AFTER_CLOSE' || e.message === 'readline was closed') {
+      // User hit Ctrl+C
+      console.log('\n\nAborted.');
+      process.exit(1);
+    }
+    console.error(`\nFatal error: ${e.message}`);
+    process.exit(1);
+  }
+}
+
+main().catch(e => {
+  console.error(`\nFatal error: ${e.message}`);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "lattice-install",
+  "version": "0.1.0",
+  "description": "Onboard to Lattice Network in 60 seconds",
+  "bin": {"lattice-install": "bin/lattice-install.js"},
+  "engines": {"node": ">=18"},
+  "keywords": ["lattice", "ai", "proxy", "anthropic", "openai", "bft"],
+  "license": "MIT"
+}