@mmmbuto/nexuscli 0.5.0

package/lib/cli/workspaces.js

@@ -0,0 +1,337 @@
+/**
+ * nexuscli workspaces - Manage workspace directories
+ *
+ * Usage:
+ *   nexuscli workspaces                - List configured workspaces
+ *   nexuscli workspaces list           - List configured workspaces
+ *   nexuscli workspaces set-default <path> - Set default workspace
+ *   nexuscli workspaces add <path>     - Add workspace to list
+ *   nexuscli workspaces remove <path>  - Remove workspace from list
+ *   nexuscli workspaces scan           - Scan for Claude/Codex sessions
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const chalk = require('chalk');
+const { getConfig, setConfigValue, getConfigValue } = require('../config/manager');
+
+// Directories to scan for sessions
+const SCAN_ROOTS = [
+  path.join(os.homedir(), 'Dev'),
+  path.join(os.homedir(), 'Projects'),
+  path.join(os.homedir(), 'projects'),
+  path.join(os.homedir(), 'src'),
+  path.join(os.homedir(), 'code'),
+  path.join(os.homedir(), 'work'),
+  os.homedir()
+];
+
+// CLI session directories
+const CLAUDE_PROJECTS = path.join(os.homedir(), '.claude', 'projects');
+const CODEX_SESSIONS = path.join(os.homedir(), '.codex', 'sessions');
+
+/**
+ * Expand ~ to home directory
+ */
+function expandPath(p) {
+  if (!p) return p;
+  if (p.startsWith('~/')) {
+    return path.join(os.homedir(), p.slice(2));
+  }
+  return path.resolve(p);
+}
+
+/**
+ * Collapse home directory to ~
+ */
+function collapsePath(p) {
+  const home = os.homedir();
+  if (p.startsWith(home)) {
+    return '~' + p.slice(home.length);
+  }
+  return p;
+}
+
+/**
+ * Convert workspace path to Claude projects slug
+ */
+function pathToSlug(workspacePath) {
+  return workspacePath.replace(/\//g, '-').replace(/\./g, '-');
+}
+
+/**
+ * List configured workspaces
+ */
+function listWorkspaces() {
+  const config = getConfig();
+  const defaultWs = expandPath(config.workspaces?.default || '~/Dev');
+  const paths = config.workspaces?.paths || [];
+
+  console.log('\n' + chalk.cyan('📁 Configured Workspaces:\n'));
+
+  if (paths.length === 0) {
+    console.log(chalk.gray('  No workspaces configured.'));
+    console.log(chalk.gray('  Run: nexuscli workspaces scan'));
+  } else {
+    paths.forEach(ws => {
+      const expanded = expandPath(ws);
+      const isDefault = expanded === defaultWs;
+      const exists = fs.existsSync(expanded);
+
+      const marker = isDefault ? chalk.green('★ ') : '  ';
+      const pathDisplay = collapsePath(expanded);
+      const status = exists ? '' : chalk.red(' (not found)');
+
+      console.log(`${marker}${chalk.white(pathDisplay)}${status}`);
+    });
+  }
+
+  console.log('\n' + chalk.gray(`Default: ${collapsePath(defaultWs)}`));
+  console.log('');
+}
+
+/**
+ * Set default workspace
+ */
+function setDefault(workspacePath) {
+  if (!workspacePath) {
+    console.log(chalk.red('\n❌ Usage: nexuscli workspaces set-default <path>\n'));
+    return;
+  }
+
+  const expanded = expandPath(workspacePath);
+
+  if (!fs.existsSync(expanded)) {
+    console.log(chalk.red(`\n❌ Path not found: ${expanded}\n`));
+    return;
+  }
+
+  if (!fs.statSync(expanded).isDirectory()) {
+    console.log(chalk.red(`\n❌ Not a directory: ${expanded}\n`));
+    return;
+  }
+
+  // Set as default
+  setConfigValue('workspaces.default', collapsePath(expanded));
+
+  // Also add to paths if not present
+  const paths = getConfigValue('workspaces.paths') || [];
+  const collapsed = collapsePath(expanded);
+  if (!paths.includes(collapsed) && !paths.includes(expanded)) {
+    paths.push(collapsed);
+    setConfigValue('workspaces.paths', paths);
+  }
+
+  console.log(chalk.green(`\n✅ Default workspace set to: ${collapsed}\n`));
+}
+
+/**
+ * Add workspace to list
+ */
+function addWorkspace(workspacePath) {
+  if (!workspacePath) {
+    console.log(chalk.red('\n❌ Usage: nexuscli workspaces add <path>\n'));
+    return;
+  }
+
+  const expanded = expandPath(workspacePath);
+
+  if (!fs.existsSync(expanded)) {
+    console.log(chalk.red(`\n❌ Path not found: ${expanded}\n`));
+    return;
+  }
+
+  if (!fs.statSync(expanded).isDirectory()) {
+    console.log(chalk.red(`\n❌ Not a directory: ${expanded}\n`));
+    return;
+  }
+
+  const paths = getConfigValue('workspaces.paths') || [];
+  const collapsed = collapsePath(expanded);
+
+  if (paths.includes(collapsed) || paths.includes(expanded)) {
+    console.log(chalk.yellow(`\n⚠️  Workspace already in list: ${collapsed}\n`));
+    return;
+  }
+
+  paths.push(collapsed);
+  setConfigValue('workspaces.paths', paths);
+
+  console.log(chalk.green(`\n✅ Added workspace: ${collapsed}\n`));
+}
+
+/**
+ * Remove workspace from list
+ */
+function removeWorkspace(workspacePath) {
+  if (!workspacePath) {
+    console.log(chalk.red('\n❌ Usage: nexuscli workspaces remove <path>\n'));
+    return;
+  }
+
+  const expanded = expandPath(workspacePath);
+  const collapsed = collapsePath(expanded);
+
+  let paths = getConfigValue('workspaces.paths') || [];
+  const originalLen = paths.length;
+
+  paths = paths.filter(p => {
+    const pExpanded = expandPath(p);
+    return pExpanded !== expanded;
+  });
+
+  if (paths.length === originalLen) {
+    console.log(chalk.yellow(`\n⚠️  Workspace not in list: ${collapsed}\n`));
+    return;
+  }
+
+  setConfigValue('workspaces.paths', paths);
+
+  // If removed default, clear it
+  const defaultWs = expandPath(getConfigValue('workspaces.default') || '');
+  if (defaultWs === expanded) {
+    setConfigValue('workspaces.default', paths[0] || '~/Dev');
+  }
+
+  console.log(chalk.green(`\n✅ Removed workspace: ${collapsed}\n`));
+}
+
+/**
+ * Scan for workspaces with Claude/Codex sessions
+ */
+function scanWorkspaces() {
+  console.log('\n' + chalk.cyan('🔍 Scanning for workspaces with AI sessions...\n'));
+
+  const foundWorkspaces = new Map(); // path -> { claude: count, codex: count }
+
+  // 1. Scan Claude projects directory
+  if (fs.existsSync(CLAUDE_PROJECTS)) {
+    console.log(chalk.gray(`  Scanning ${CLAUDE_PROJECTS}...`));
+
+    const dirs = fs.readdirSync(CLAUDE_PROJECTS, { withFileTypes: true });
+
+    for (const dir of dirs) {
+      if (!dir.isDirectory()) continue;
+
+      const projectDir = path.join(CLAUDE_PROJECTS, dir.name);
+      const sessionFiles = fs.readdirSync(projectDir)
+        .filter(f => f.endsWith('.jsonl') && !f.startsWith('agent-'));
+
+      if (sessionFiles.length > 0) {
+        // Read workspace path from first session file
+        let workspacePath = null;
+        try {
+          const firstFile = path.join(projectDir, sessionFiles[0]);
+          const firstLine = fs.readFileSync(firstFile, 'utf8').split('\n')[0];
+          const entry = JSON.parse(firstLine);
+          workspacePath = entry.cwd;
+        } catch (err) {
+          // Fallback: convert slug back to path
+          workspacePath = '/' + dir.name.replace(/^-/, '').replace(/-/g, '/');
+        }
+
+        if (workspacePath && fs.existsSync(workspacePath)) {
+          const existing = foundWorkspaces.get(workspacePath) || { claude: 0, codex: 0 };
+          existing.claude = sessionFiles.length;
+          foundWorkspaces.set(workspacePath, existing);
+        }
+      }
+    }
+  }
+
+  // 2. Scan Codex sessions directory
+  if (fs.existsSync(CODEX_SESSIONS)) {
+    console.log(chalk.gray(`  Scanning ${CODEX_SESSIONS}...`));
+
+    const sessionFiles = fs.readdirSync(CODEX_SESSIONS)
+      .filter(f => f.endsWith('.json'));
+
+    // Codex sessions might have workspace in their metadata
+    // For now, count them without workspace association
+    if (sessionFiles.length > 0) {
+      console.log(chalk.gray(`  Found ${sessionFiles.length} Codex sessions (global)`));
+    }
+  }
+
+  // 3. Display results
+  console.log('');
+
+  if (foundWorkspaces.size === 0) {
+    console.log(chalk.yellow('  No workspaces with sessions found.\n'));
+    return;
+  }
+
+  console.log(chalk.green(`Found ${foundWorkspaces.size} workspaces with sessions:\n`));
+
+  // Sort by session count
+  const sorted = [...foundWorkspaces.entries()]
+    .sort((a, b) => (b[1].claude + b[1].codex) - (a[1].claude + a[1].codex));
+
+  // Get current configured paths
+  const currentPaths = (getConfigValue('workspaces.paths') || []).map(expandPath);
+
+  for (const [ws, counts] of sorted) {
+    const isConfigured = currentPaths.includes(ws);
+    const marker = isConfigured ? chalk.green('✓') : chalk.yellow('○');
+    const claudeCount = counts.claude ? chalk.cyan(`Claude: ${counts.claude}`) : '';
+    const codexCount = counts.codex ? chalk.magenta(`Codex: ${counts.codex}`) : '';
+    const sessionInfo = [claudeCount, codexCount].filter(Boolean).join(', ');
+
+    console.log(`  ${marker} ${collapsePath(ws)}`);
+    console.log(chalk.gray(`      ${sessionInfo}`));
+  }
+
+  // Ask to add unconfigured workspaces
+  const unconfigured = sorted.filter(([ws]) => !currentPaths.includes(ws));
+
+  if (unconfigured.length > 0) {
+    console.log(chalk.cyan(`\nTo add these workspaces, run:`));
+    for (const [ws] of unconfigured) {
+      console.log(chalk.gray(`  nexuscli workspaces add "${collapsePath(ws)}"`));
+    }
+  }
+
+  console.log('');
+}
+
+/**
+ * Main workspaces command
+ */
+async function workspacesCommand(action, arg) {
+  if (!action || action === 'list') {
+    listWorkspaces();
+    return;
+  }
+
+  switch (action) {
+    case 'set-default':
+      setDefault(arg);
+      break;
+
+    case 'add':
+      addWorkspace(arg);
+      break;
+
+    case 'remove':
+    case 'rm':
+      removeWorkspace(arg);
+      break;
+
+    case 'scan':
+      scanWorkspaces();
+      break;
+
+    default:
+      console.log(chalk.red(`\n❌ Unknown action: ${action}`));
+      console.log('\nUsage:');
+      console.log('  nexuscli workspaces           - List configured workspaces');
+      console.log('  nexuscli workspaces set-default <path> - Set default');
+      console.log('  nexuscli workspaces add <path>    - Add workspace');
+      console.log('  nexuscli workspaces remove <path> - Remove workspace');
+      console.log('  nexuscli workspaces scan          - Scan for sessions');
+      console.log('');
+  }
+}
+
+module.exports = workspacesCommand;

package/lib/config/manager.js

@@ -0,0 +1,233 @@
+/**
+ * Configuration Manager
+ * Handles reading/writing ~/.nexuscli/config.json
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { PATHS, ensureDirectories } = require('../utils/paths');
+
+/**
+ * Default configuration
+ */
+const DEFAULT_CONFIG = {
+  version: 1,
+  server: {
+    port: 41800,
+    host: '0.0.0.0'
+  },
+  auth: {
+    jwt_secret: null,  // Generated on init
+    user: 'tux',
+    pass_hash: null    // Generated on init
+  },
+  engines: {
+    active: ['claude'],
+    check_on_boot: false,  // Re-check engine availability on each boot
+    claude: {
+      enabled: true,
+      path: 'auto',
+      model: 'sonnet'
+    },
+    codex: {
+      enabled: false,
+      path: null
+    }
+  },
+  workspaces: {
+    default: null,  // Set during init - will use HOME if not configured
+    paths: []
+  },
+  termux: {
+    wake_lock: true,
+    notifications: true,
+    boot_start: false
+  }
+};
+
+/**
+ * Load configuration from file
+ */
+function loadConfig() {
+  ensureDirectories();
+
+  if (!fs.existsSync(PATHS.CONFIG_FILE)) {
+    return null;
+  }
+
+  try {
+    const content = fs.readFileSync(PATHS.CONFIG_FILE, 'utf8');
+    return JSON.parse(content);
+  } catch (error) {
+    console.error('Error loading config:', error.message);
+    return null;
+  }
+}
+
+/**
+ * Save configuration to file
+ */
+function saveConfig(config) {
+  ensureDirectories();
+
+  try {
+    fs.writeFileSync(
+      PATHS.CONFIG_FILE,
+      JSON.stringify(config, null, 2),
+      'utf8'
+    );
+    return true;
+  } catch (error) {
+    console.error('Error saving config:', error.message);
+    return false;
+  }
+}
+
+/**
+ * Get configuration (load or create default)
+ */
+function getConfig() {
+  const config = loadConfig();
+  if (config) {
+    return config;
+  }
+  return { ...DEFAULT_CONFIG };
+}
+
+/**
+ * Check if NexusCLI is initialized
+ */
+function isInitialized() {
+  return fs.existsSync(PATHS.CONFIG_FILE);
+}
+
+/**
+ * Get a config value by dot-notation path
+ * e.g., 'server.port' -> config.server.port
+ */
+function getConfigValue(key) {
+  const config = getConfig();
+  const parts = key.split('.');
+  let value = config;
+
+  for (const part of parts) {
+    if (value === undefined || value === null) {
+      return undefined;
+    }
+    value = value[part];
+  }
+
+  return value;
+}
+
+/**
+ * Set a config value by dot-notation path
+ */
+function setConfigValue(key, value) {
+  const config = getConfig();
+  const parts = key.split('.');
+  let current = config;
+
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    if (current[part] === undefined) {
+      current[part] = {};
+    }
+    current = current[part];
+  }
+
+  // Parse value type
+  let parsedValue = value;
+  if (value === 'true') parsedValue = true;
+  else if (value === 'false') parsedValue = false;
+  else if (!isNaN(value) && value !== '') parsedValue = Number(value);
+
+  current[parts[parts.length - 1]] = parsedValue;
+
+  return saveConfig(config);
+}
+
+/**
+ * Get all config keys as flat list
+ */
+function getConfigKeys(obj = null, prefix = '') {
+  if (!obj) {
+    obj = getConfig();
+  }
+
+  const keys = [];
+
+  for (const key of Object.keys(obj)) {
+    const fullKey = prefix ? `${prefix}.${key}` : key;
+
+    if (typeof obj[key] === 'object' && obj[key] !== null && !Array.isArray(obj[key])) {
+      keys.push(...getConfigKeys(obj[key], fullKey));
+    } else {
+      keys.push(fullKey);
+    }
+  }
+
+  return keys;
+}
+
+/**
+ * Initialize config with generated secrets
+ */
+function initializeConfig(options = {}) {
+  const { v4: uuidv4 } = require('uuid');
+  const bcrypt = require('bcryptjs');
+
+  const config = { ...DEFAULT_CONFIG };
+
+  // Generate JWT secret
+  config.auth.jwt_secret = uuidv4() + '-' + uuidv4();
+
+  // Set user credentials
+  const username = options.username || 'tux';
+  const password = options.password || 'tux';
+
+  config.auth.user = username;
+  config.auth.pass_hash = bcrypt.hashSync(password, 10);
+
+  // Set workspaces
+  if (options.workspaces) {
+    config.workspaces.paths = options.workspaces;
+  }
+
+  // Set default workspace (explicit or first from list)
+  if (options.defaultWorkspace) {
+    config.workspaces.default = options.defaultWorkspace;
+  } else if (options.workspaces && options.workspaces.length > 0) {
+    config.workspaces.default = options.workspaces[0];
+  }
+
+  // Set port
+  if (options.port) {
+    config.server.port = options.port;
+  }
+
+  // Termux options
+  if (options.wakeLock !== undefined) {
+    config.termux.wake_lock = options.wakeLock;
+  }
+  if (options.notifications !== undefined) {
+    config.termux.notifications = options.notifications;
+  }
+  if (options.bootStart !== undefined) {
+    config.termux.boot_start = options.bootStart;
+  }
+
+  return saveConfig(config) ? config : null;
+}
+
+module.exports = {
+  DEFAULT_CONFIG,
+  loadConfig,
+  saveConfig,
+  getConfig,
+  isInitialized,
+  getConfigValue,
+  setConfigValue,
+  getConfigKeys,
+  initializeConfig
+};

package/lib/server/.env.example

@@ -0,0 +1,20 @@
+# NexusCLI Backend Configuration
+
+# Port (NexusCLI Chaos Standard: 41800)
+# 418 = ABRAHADABRA (Word of the Aeon, Crowley/Thelema)
+# Represents the Great Work complete (Chaos Magic supreme formula)
+# Range 41800-41899 (100 ports, UNIVERSAL compatibility, NO Elasticsearch conflict)
+PORT=41800
+
+# Database path (auto-detected for Linux/Termux)
+# Linux:   /var/lib/nexuscli/nexuscli.db
+# Termux:  $HOME/.nexuscli/nexuscli.db
+
+# Node environment
+NODE_ENV=production
+
+# Workspace directory for CLI execution
+WORKSPACE_DIR=/home/user/myproject
+
+# Timeout for CLI commands (ms)
+DEFAULT_TIMEOUT=30000