@jlongo78/agent-spaces 0.3.12 → 0.5.0

package/bin/spaces-install.js

@@ -0,0 +1,425 @@
+#!/usr/bin/env node
+
+'use strict';
+
+const { execFileSync } = require('child_process');
+const path = require('path');
+const os = require('os');
+const fs = require('fs');
+
+const PACKAGES_DIR = path.join(os.homedir(), '.spaces', 'packages');
+const NODE_MODULES_DIR = path.join(PACKAGES_DIR, 'node_modules', '@spaces');
+
+// ─── Package definitions ─────────────────────────────────────
+const PACKAGES = {
+  teams: {
+    name: '@spaces/teams',
+    dir: path.join(PACKAGES_DIR, 'teams'),
+    repo: 'jlongo78/spaces-teams',
+    private: false,
+    verify: (dir) => fs.existsSync(path.join(dir, 'dist', 'index.js')),
+    verifyLabel: 'dist/index.js',
+  },
+  pro: {
+    name: '@spaces/pro',
+    dir: path.join(PACKAGES_DIR, 'pro'),
+    repo: 'jlongo78/spaces-pro',
+    private: true,
+    verify: (dir) => fs.existsSync(path.join(dir, 'dist', 'index.js')),
+    verifyLabel: 'dist/index.js',
+  },
+};
+
+// ─── Helpers ──────────────────────────────────────────────────
+function log(msg) { console.log(`  ${msg}`); }
+function logOk(msg) { console.log(`  ✓ ${msg}`); }
+function logErr(msg) { console.error(`  ✗ ${msg}`); }
+function logWarn(msg) { console.log(`  ! ${msg}`); }
+
+function run(cmd, args, opts = {}) {
+  return execFileSync(cmd, args, {
+    encoding: 'utf-8',
+    stdio: opts.quiet ? ['pipe', 'pipe', 'pipe'] : 'inherit',
+    ...opts,
+  });
+}
+
+/**
+ * Clone a repo, trying SSH first then HTTPS (with optional PAT).
+ */
+function gitClone(repo, dest, isPrivate) {
+  const sshUrl = `git@github.com:${repo}.git`;
+  const httpsUrl = `https://github.com/${repo}.git`;
+
+  // Try SSH first
+  try {
+    log(`Cloning ${repo} (SSH)...`);
+    run('git', ['clone', '--depth', '1', sshUrl, dest]);
+    return;
+  } catch {
+    // SSH failed, try HTTPS
+  }
+
+  // HTTPS — check for PAT if private
+  if (isPrivate) {
+    const pat = process.env.GH_PAT || process.env.GITHUB_TOKEN || '';
+    if (pat) {
+      log(`Cloning ${repo} (HTTPS + token)...`);
+      const authedUrl = `https://${pat}@github.com/${repo}.git`;
+      run('git', ['clone', '--depth', '1', authedUrl, dest]);
+      return;
+    }
+  }
+
+  log(`Cloning ${repo} (HTTPS)...`);
+  run('git', ['clone', '--depth', '1', httpsUrl, dest]);
+}
+
+/**
+ * Pull latest changes in a repo directory.
+ */
+function gitPull(dir) {
+  log('Pulling latest...');
+  run('git', ['pull', '--ff-only'], { cwd: dir });
+}
+
+/**
+ * Create the symlink from node_modules/@spaces/<name> -> ../../<name>
+ */
+function createSymlink(pkgKey) {
+  const linkPath = path.join(NODE_MODULES_DIR, pkgKey);
+  const targetPath = path.join('..', '..', pkgKey); // relative symlink
+
+  fs.mkdirSync(NODE_MODULES_DIR, { recursive: true });
+
+  // Remove existing link/dir
+  try {
+    const stat = fs.lstatSync(linkPath);
+    if (stat.isSymbolicLink() || stat.isFile()) {
+      fs.unlinkSync(linkPath);
+    } else if (stat.isDirectory()) {
+      fs.rmSync(linkPath, { recursive: true });
+    }
+  } catch {}
+
+  fs.symlinkSync(targetPath, linkPath, 'dir');
+  logOk(`Symlink: @spaces/${pkgKey} -> packages/${pkgKey}`);
+}
+
+/**
+ * Check if a native module loads correctly from a package directory.
+ */
+function checkNativeModule(moduleName, searchDir) {
+  try {
+    const nodePath = path.join(searchDir, 'node_modules');
+    const result = run(process.execPath, [
+      '-e',
+      `try { require('${moduleName}'); console.log('ok'); } catch(e) { console.log(e.message); }`,
+    ], {
+      quiet: true,
+      cwd: searchDir,
+      env: { ...process.env, NODE_PATH: nodePath },
+    });
+    return result.trim() === 'ok';
+  } catch {
+    return false;
+  }
+}
+
+// ─── Install command ──────────────────────────────────────────
+function installPackage(pkgKey) {
+  const pkg = PACKAGES[pkgKey];
+  if (!pkg) {
+    logErr(`Unknown package: ${pkgKey}`);
+    log(`Available: ${Object.keys(PACKAGES).join(', ')}`);
+    process.exit(1);
+  }
+
+  console.log(`\n  Installing ${pkg.name}...\n`);
+
+  // 1. Clone or pull
+  if (fs.existsSync(path.join(pkg.dir, '.git'))) {
+    gitPull(pkg.dir);
+  } else {
+    fs.mkdirSync(PACKAGES_DIR, { recursive: true });
+    gitClone(pkg.repo, pkg.dir, pkg.private);
+  }
+
+  // 2. Install dependencies
+  // Both teams and pro need TypeScript build
+  log('Installing dependencies...');
+  run('npm', ['install'], { cwd: pkg.dir });
+
+  log('Building TypeScript...');
+  run('npm', ['run', 'build'], { cwd: pkg.dir });
+
+  log('Pruning dev dependencies...');
+  run('npm', ['prune', '--omit=dev'], { cwd: pkg.dir });
+
+  // 5. Create symlink
+  createSymlink(pkgKey);
+
+  // 6. Verify
+  if (pkg.verify(pkg.dir)) {
+    logOk(`${pkg.name} installed successfully`);
+  } else {
+    logErr(`${pkg.name} installed but ${pkg.verifyLabel} not found`);
+    process.exit(1);
+  }
+
+  // 7. Verify require() works
+  try {
+    const result = run(process.execPath, [
+      '-e',
+      `const p = require.resolve('${pkg.name}'); console.log('resolved: ' + p);`,
+    ], {
+      quiet: true,
+      env: { ...process.env, NODE_PATH: path.join(PACKAGES_DIR, 'node_modules') },
+    });
+    logOk(`require('${pkg.name}') -> ${result.trim().replace('resolved: ', '')}`);
+  } catch {
+    logWarn(`require('${pkg.name}') failed — this may be OK if peer deps aren't available yet`);
+  }
+
+  console.log('');
+}
+
+// ─── Verify command ───────────────────────────────────────────
+function verifyAll() {
+  console.log('\n  Spaces Package Verification\n');
+
+  let allOk = true;
+
+  for (const [key, pkg] of Object.entries(PACKAGES)) {
+    log(`─── ${pkg.name} ───`);
+
+    // Check if installed
+    if (!fs.existsSync(pkg.dir)) {
+      logWarn('Not installed');
+      log('');
+      continue;
+    }
+
+    // Check git status
+    try {
+      const branch = run('git', ['rev-parse', '--abbrev-ref', 'HEAD'], { cwd: pkg.dir, quiet: true }).trim();
+      const hash = run('git', ['rev-parse', '--short', 'HEAD'], { cwd: pkg.dir, quiet: true }).trim();
+      logOk(`Git: ${branch} @ ${hash}`);
+    } catch {
+      logErr('Git status check failed');
+      allOk = false;
+    }
+
+    // Check entry point
+    if (pkg.verify(pkg.dir)) {
+      logOk(`Entry: ${pkg.verifyLabel} exists`);
+    } else {
+      logErr(`Entry: ${pkg.verifyLabel} missing`);
+      allOk = false;
+    }
+
+    // Check node_modules
+    if (fs.existsSync(path.join(pkg.dir, 'node_modules'))) {
+      logOk('Dependencies: node_modules present');
+    } else {
+      logErr('Dependencies: node_modules missing');
+      allOk = false;
+    }
+
+    // Check symlink
+    const linkPath = path.join(NODE_MODULES_DIR, key);
+    try {
+      const stat = fs.lstatSync(linkPath);
+      if (stat.isSymbolicLink()) {
+        const target = fs.readlinkSync(linkPath);
+        logOk(`Symlink: @spaces/${key} -> ${target}`);
+      } else {
+        logWarn(`@spaces/${key} exists but is not a symlink`);
+      }
+    } catch {
+      logErr(`Symlink: @spaces/${key} missing`);
+      allOk = false;
+    }
+
+    // Check native modules
+    const nativeOk = checkNativeModule('better-sqlite3', pkg.dir);
+    if (nativeOk) {
+      logOk('Native: better-sqlite3 loads OK');
+    } else {
+      logErr('Native: better-sqlite3 failed (ABI mismatch? Run: spaces upgrade)');
+      allOk = false;
+    }
+
+    // Check require() resolution
+    try {
+      run(process.execPath, [
+        '-e',
+        `require.resolve('${pkg.name}')`,
+      ], {
+        quiet: true,
+        env: { ...process.env, NODE_PATH: path.join(PACKAGES_DIR, 'node_modules') },
+      });
+      logOk(`require('${pkg.name}') resolves OK`);
+    } catch {
+      logErr(`require('${pkg.name}') fails`);
+      allOk = false;
+    }
+
+    log('');
+  }
+
+  if (allOk) {
+    logOk('All checks passed');
+  } else {
+    logErr('Some checks failed — run "spaces upgrade" to fix');
+  }
+  console.log('');
+}
+
+// ─── Upgrade command ──────────────────────────────────────────
+function upgradePackage(pkgKey) {
+  if (pkgKey) {
+    // Upgrade specific package
+    const pkg = PACKAGES[pkgKey];
+    if (!pkg) {
+      logErr(`Unknown package: ${pkgKey}`);
+      process.exit(1);
+    }
+    if (!fs.existsSync(pkg.dir)) {
+      log(`${pkg.name} not installed — running install instead`);
+      installPackage(pkgKey);
+      return;
+    }
+    console.log(`\n  Upgrading ${pkg.name}...\n`);
+    doUpgrade(pkgKey, pkg);
+  } else {
+    // Upgrade all installed packages
+    console.log('\n  Upgrading all installed packages...\n');
+    for (const [key, pkg] of Object.entries(PACKAGES)) {
+      if (fs.existsSync(pkg.dir)) {
+        log(`─── ${pkg.name} ───`);
+        doUpgrade(key, pkg);
+        log('');
+      }
+    }
+  }
+  console.log('');
+}
+
+function doUpgrade(pkgKey, pkg) {
+  // Pull latest
+  gitPull(pkg.dir);
+
+  run('npm', ['install'], { cwd: pkg.dir });
+  log('Building TypeScript...');
+  run('npm', ['run', 'build'], { cwd: pkg.dir });
+  run('npm', ['prune', '--omit=dev'], { cwd: pkg.dir });
+
+  // Re-create symlink
+  createSymlink(pkgKey);
+
+  if (pkg.verify(pkg.dir)) {
+    logOk(`${pkg.name} upgraded successfully`);
+  } else {
+    logErr(`${pkg.name} upgrade failed — ${pkg.verifyLabel} not found`);
+  }
+}
+
+// ─── Uninstall command ────────────────────────────────────────
+function uninstallOne(pkgKey) {
+  const pkg = PACKAGES[pkgKey];
+
+  // Remove symlink
+  const linkPath = path.join(NODE_MODULES_DIR, pkgKey);
+  try {
+    const stat = fs.lstatSync(linkPath);
+    if (stat.isSymbolicLink() || stat.isFile()) {
+      fs.unlinkSync(linkPath);
+    } else if (stat.isDirectory()) {
+      fs.rmSync(linkPath, { recursive: true });
+    }
+    logOk(`Removed symlink @spaces/${pkgKey}`);
+  } catch {
+    logWarn(`Symlink @spaces/${pkgKey} not found`);
+  }
+
+  // Remove package directory
+  if (fs.existsSync(pkg.dir)) {
+    fs.rmSync(pkg.dir, { recursive: true });
+    logOk(`Removed ${pkg.dir}`);
+  } else {
+    logWarn(`${pkg.dir} not found`);
+  }
+}
+
+function uninstallPackage(pkgKey) {
+  if (pkgKey) {
+    const pkg = PACKAGES[pkgKey];
+    if (!pkg) {
+      logErr(`Unknown package: ${pkgKey}`);
+      log(`Available: ${Object.keys(PACKAGES).join(', ')}`);
+      process.exit(1);
+    }
+    console.log(`\n  Uninstalling ${pkg.name}...\n`);
+    uninstallOne(pkgKey);
+    logOk(`${pkg.name} uninstalled`);
+  } else {
+    console.log('\n  Uninstalling everything...\n');
+
+    // Remove tier packages
+    for (const [key, pkg] of Object.entries(PACKAGES)) {
+      if (fs.existsSync(pkg.dir) || fs.existsSync(path.join(NODE_MODULES_DIR, key))) {
+        log(`─── ${pkg.name} ───`);
+        uninstallOne(key);
+      }
+    }
+    // Clean up packages dir
+    try { fs.rmdirSync(NODE_MODULES_DIR); } catch {}
+    try { fs.rmdirSync(path.join(PACKAGES_DIR, 'node_modules')); } catch {}
+    try { fs.rmdirSync(PACKAGES_DIR); } catch {}
+
+    // Remove the global spaces CLI
+    log('─── @jlongo78/agent-spaces ───');
+    try {
+      run('npm', ['uninstall', '-g', '@jlongo78/agent-spaces'], { quiet: true });
+      logOk('Removed global spaces CLI');
+    } catch {
+      logWarn('Global spaces CLI not found or already removed');
+    }
+
+    logOk('Spaces fully uninstalled');
+    log('User data remains at ~/.spaces/ — remove manually if desired');
+  }
+  console.log('');
+}
+
+// ─── CLI ──────────────────────────────────────────────────────
+const command = process.argv[2];
+const target = process.argv[3];
+
+switch (command) {
+  case 'install':
+    if (!target) {
+      logErr('Usage: spaces install <teams|pro>');
+      process.exit(1);
+    }
+    installPackage(target);
+    break;
+
+  case 'uninstall':
+    uninstallPackage(target || null);
+    break;
+
+  case 'verify':
+    verifyAll();
+    break;
+
+  case 'upgrade':
+    upgradePackage(target || null);
+    break;
+
+  default:
+    logErr(`Unknown command: ${command}`);
+    log('Usage: spaces <install|uninstall|verify|upgrade> [package]');
+    process.exit(1);
+}

package/bin/spaces-setup.js

@@ -0,0 +1,242 @@
+#!/usr/bin/env node
+
+// Setup wizard for Spaces server edition.
+// Run via: spaces --setup
+
+const Database = require('better-sqlite3');
+const crypto = require('crypto');
+const readline = require('readline');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+const SPACES_DIR = path.join(os.homedir(), '.spaces');
+const CONFIG_PATH = path.join(SPACES_DIR, 'server.json');
+const ADMIN_DB_PATH = path.join(SPACES_DIR, 'admin.db');
+const SESSION_SECRET_PATH = path.join(SPACES_DIR, 'session_secret');
+
+function prompt(rl, question, defaultValue) {
+  const suffix = defaultValue ? ` [${defaultValue}]` : '';
+  return new Promise((resolve) => rl.question(`  ${question}${suffix}: `, (answer) => {
+    resolve(answer.trim() || defaultValue || '');
+  }));
+}
+
+function promptHidden(question) {
+  return new Promise((resolve) => {
+    const stdin = process.stdin;
+    const stdout = process.stdout;
+    stdout.write(`  ${question}: `);
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding('utf8');
+
+    let password = '';
+    const onData = (ch) => {
+      if (ch === '\n' || ch === '\r' || ch === '\u0004') {
+        stdin.setRawMode(false);
+        stdin.pause();
+        stdin.removeListener('data', onData);
+        stdout.write('\n');
+        resolve(password);
+      } else if (ch === '\u0003') {
+        process.exit(1);
+      } else if (ch === '\u007F' || ch === '\b') {
+        if (password.length > 0) {
+          password = password.slice(0, -1);
+          stdout.write('\b \b');
+        }
+      } else {
+        password += ch;
+        stdout.write('*');
+      }
+    };
+    stdin.on('data', onData);
+  });
+}
+
+function hashPassword(password) {
+  const salt = crypto.randomBytes(16).toString('hex');
+  const hash = crypto.scryptSync(password, salt, 64).toString('hex');
+  return `${salt}:${hash}`;
+}
+
+async function main() {
+  console.log('');
+  console.log('  Spaces — Server Setup');
+  console.log('  =====================');
+  console.log('');
+
+  // Ensure ~/.spaces directory
+  if (!fs.existsSync(SPACES_DIR)) {
+    fs.mkdirSync(SPACES_DIR, { recursive: true });
+  }
+
+  // Detect @spaces/pro
+  let hasSpacesPro = false;
+  try { require.resolve('@spaces/pro'); hasSpacesPro = true; } catch {}
+
+  if (hasSpacesPro) {
+    console.log('  Detected @spaces/pro — full features available.');
+  } else {
+    console.log('  @spaces/pro not found — community features only.');
+    console.log('  Install @spaces/pro for auth, multi-user, and federation.');
+  }
+  console.log('');
+
+  // Load existing config
+  let existingConfig = {};
+  if (fs.existsSync(CONFIG_PATH)) {
+    try { existingConfig = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf-8')); } catch {}
+  }
+
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+
+  // Tier
+  const defaultTier = existingConfig.tier || (hasSpacesPro ? 'federation' : 'community');
+  const tier = await prompt(rl, 'Tier (community|server|team|federation)', defaultTier);
+  const validTiers = ['community', 'server', 'team', 'federation'];
+  if (!validTiers.includes(tier)) {
+    console.error(`\n  Error: Invalid tier "${tier}". Must be one of: ${validTiers.join(', ')}`);
+    process.exit(1);
+  }
+
+  const needsAuth = tier !== 'community';
+
+  // Admin user (non-community tiers)
+  if (needsAuth) {
+    console.log('');
+    console.log('  Admin User');
+    console.log('  ──────────');
+
+    // Generate session secret if missing
+    if (!fs.existsSync(SESSION_SECRET_PATH)) {
+      const hex = crypto.randomBytes(32).toString('hex');
+      fs.writeFileSync(SESSION_SECRET_PATH, hex, { mode: 0o600 });
+      console.log(`  Generated session secret at ${SESSION_SECRET_PATH}`);
+    }
+
+    // Open/create admin database
+    const db = new Database(ADMIN_DB_PATH);
+    db.pragma('journal_mode = WAL');
+    db.pragma('synchronous = NORMAL');
+    db.pragma('foreign_keys = ON');
+
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS users (
+        id TEXT PRIMARY KEY,
+        username TEXT NOT NULL UNIQUE,
+        password_hash TEXT NOT NULL,
+        display_name TEXT NOT NULL DEFAULT '',
+        shell_user TEXT NOT NULL,
+        role TEXT NOT NULL DEFAULT 'user',
+        totp_secret TEXT,
+        totp_enabled INTEGER DEFAULT 0,
+        created TEXT DEFAULT (datetime('now'))
+      );
+    `);
+
+    const existingAdmin = db.prepare("SELECT username FROM users WHERE role = 'admin' LIMIT 1").get();
+    if (existingAdmin) {
+      console.log(`  Admin user already exists: ${existingAdmin.username}`);
+    } else {
+      const username = await prompt(rl, 'Username', 'admin');
+      if (!username) {
+        console.error('  Error: username cannot be empty');
+        process.exit(1);
+      }
+
+      const existing = db.prepare('SELECT id FROM users WHERE username = ?').get(username);
+      if (existing) {
+        console.error(`  Error: user "${username}" already exists`);
+        process.exit(1);
+      }
+
+      rl.close();
+
+      const password = await promptHidden('Password');
+      if (password.length < 8) {
+        console.error('  Error: password must be at least 8 characters');
+        process.exit(1);
+      }
+
+      const confirm = await promptHidden('Confirm password');
+      if (password !== confirm) {
+        console.error('  Error: passwords do not match');
+        process.exit(1);
+      }
+
+      const rl2 = readline.createInterface({ input: process.stdin, output: process.stdout });
+      const displayName = await prompt(rl2, 'Display name', username);
+      rl2.close();
+
+      const shellUser = os.userInfo().username;
+      const id = crypto.randomUUID();
+      const passwordHash = hashPassword(password);
+
+      db.prepare(`
+        INSERT INTO users (id, username, password_hash, display_name, shell_user, role)
+        VALUES (?, ?, ?, ?, ?, 'admin')
+      `).run(id, username, passwordHash, displayName, shellUser);
+
+      console.log(`\n  Admin user "${username}" created.`);
+    }
+    db.close();
+  }
+
+  // Server config
+  console.log('');
+  console.log('  Server');
+  console.log('  ──────────');
+
+  // Close rl if it's still open (community path or existing admin path)
+  try { rl.close(); } catch {}
+  const rl3 = readline.createInterface({ input: process.stdin, output: process.stdout });
+
+  const defaultPort = existingConfig.port || 3457;
+  const portStr = await prompt(rl3, 'Port', String(defaultPort));
+  const port = parseInt(portStr, 10) || defaultPort;
+
+  const defaultBasePath = existingConfig.basePath || '';
+  const basePath = await prompt(rl3, 'Base path (leave empty for root)', defaultBasePath);
+
+  rl3.close();
+
+  // Save config
+  const config = { tier, port, basePath };
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
+
+  console.log('');
+  console.log(`  Saved to ${CONFIG_PATH}`);
+
+  // Generate proxy config hints if basePath is set
+  if (basePath) {
+    console.log('');
+    console.log('  Reverse Proxy Configuration');
+    console.log('  ───────────────────────────');
+    console.log('');
+    console.log('  For nginx:');
+    console.log(`    location ${basePath}/ {`);
+    console.log(`        proxy_pass http://localhost:${port}/;`);
+    console.log('        proxy_http_version 1.1;');
+    console.log('        proxy_set_header Upgrade $http_upgrade;');
+    console.log('        proxy_set_header Connection "upgrade";');
+    console.log('        proxy_set_header Host $host;');
+    console.log('        proxy_set_header X-Real-IP $remote_addr;');
+    console.log('    }');
+    console.log('');
+    console.log('  For Traefik (docker-compose labels):');
+    console.log(`    - "traefik.http.routers.spaces.rule=PathPrefix(\`${basePath}\`)"`);
+    console.log(`    - "traefik.http.middlewares.spaces-strip.stripprefix.prefixes=${basePath}"`);
+    console.log('    - "traefik.http.routers.spaces.middlewares=spaces-strip"');
+  }
+
+  console.log('');
+  console.log('  Start with: spaces');
+  console.log('');
+}
+
+main().catch((err) => {
+  console.error(`\n  Error: ${err.message}`);
+  process.exit(1);
+});