@swarmai/local-agent 0.1.0

package/src/toolScanner.js

@@ -0,0 +1,221 @@
+/**
+ * Tool Scanner for Local Agent
+ *
+ * Auto-detects installed developer tools on the local machine.
+ * Reports tool inventory to the server on connect.
+ * Uses parallel scanning for faster startup.
+ */
+
+const { execSync, exec } = require('child_process');
+const os = require('os');
+
+const isWindows = os.platform() === 'win32';
+
+/**
+ * Tools to scan for (name, detection command, version command)
+ */
+const TOOL_DEFINITIONS = [
+  { id: 'git', versionCmd: 'git --version', versionRegex: /git version ([\d.]+)/ },
+  { id: 'node', versionCmd: 'node --version', versionRegex: /v?([\d.]+)/ },
+  { id: 'npm', versionCmd: 'npm --version', versionRegex: /([\d.]+)/ },
+  { id: 'python', versionCmd: 'python3 --version || python --version', versionRegex: /Python ([\d.]+)/ },
+  { id: 'docker', versionCmd: 'docker --version', versionRegex: /Docker version ([\d.]+)/ },
+  { id: 'claude', versionCmd: 'claude --version', versionRegex: /([\d.]+)/ },
+  { id: 'gemini', versionCmd: 'gemini --version', versionRegex: /([\d.]+)/ },
+  { id: 'aws', versionCmd: 'aws --version', versionRegex: /aws-cli\/([\d.]+)/ },
+  { id: 'gh', versionCmd: 'gh --version', versionRegex: /gh version ([\d.]+)/ },
+  { id: 'code', versionCmd: 'code --version', versionRegex: /([\d.]+)/ },
+  { id: 'curl', versionCmd: 'curl --version', versionRegex: /curl ([\d.]+)/ },
+  { id: 'ffmpeg', versionCmd: 'ffmpeg -version', versionRegex: /ffmpeg version ([\d.]+)/ },
+  { id: 'opencode', versionCmd: 'opencode --version', versionRegex: /([\d.]+)/ },
+  { id: 'ollama', versionCmd: 'ollama --version', versionRegex: /ollama version ([\d.]+)/i },
+  { id: 'lmstudio', versionCmd: 'lms version', versionRegex: /([\d.]+)/ },
+];
+
+/**
+ * Check if a tool exists and get its version (async, non-blocking)
+ */
+function checkToolAsync(toolDef) {
+  return new Promise((resolve) => {
+    exec(toolDef.versionCmd, {
+      encoding: 'utf-8',
+      timeout: 5000,
+      shell: true,
+      windowsHide: true,
+    }, (err, stdout) => {
+      if (err) {
+        return resolve({ installed: false, version: null, path: null });
+      }
+
+      const output = (stdout || '').trim();
+      const match = output.match(toolDef.versionRegex);
+      const version = match ? match[1] : 'unknown';
+
+      // Try to get the path (async)
+      const whichCmd = isWindows ? `where ${toolDef.id}` : `which ${toolDef.id}`;
+      exec(whichCmd, { encoding: 'utf-8', timeout: 3000, windowsHide: true }, (pathErr, pathOut) => {
+        const toolPath = pathErr ? null : (pathOut || '').trim().split('\n')[0].trim();
+        resolve({ installed: true, version, path: toolPath });
+      });
+    });
+  });
+}
+
+/**
+ * Check if a tool exists (sync fallback)
+ */
+function checkTool(toolDef) {
+  try {
+    const output = execSync(toolDef.versionCmd, {
+      encoding: 'utf-8',
+      timeout: 5000,
+      stdio: ['pipe', 'pipe', 'pipe'],
+      shell: true,
+      windowsHide: true,
+    }).trim();
+
+    const match = output.match(toolDef.versionRegex);
+    const version = match ? match[1] : 'unknown';
+
+    let toolPath = null;
+    try {
+      const whichCmd = isWindows ? `where ${toolDef.id}` : `which ${toolDef.id}`;
+      toolPath = execSync(whichCmd, {
+        encoding: 'utf-8',
+        timeout: 3000,
+        stdio: ['pipe', 'pipe', 'pipe'],
+        windowsHide: true,
+      }).trim().split('\n')[0].trim();
+    } catch { /* path detection optional */ }
+
+    return { installed: true, version, path: toolPath };
+  } catch {
+    return { installed: false, version: null, path: null };
+  }
+}
+
+/**
+ * Scan Docker environment — running containers, images, compose availability
+ */
+function scanDocker() {
+  const result = { available: false, containers: [], images: 0, composeAvailable: false };
+
+  try {
+    execSync('docker --version', { encoding: 'utf-8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'], shell: true, windowsHide: true });
+    result.available = true;
+  } catch {
+    return result;
+  }
+
+  try {
+    const raw = execSync('docker ps --format "{{.Names}}\\t{{.Image}}\\t{{.Status}}\\t{{.State}}"', {
+      encoding: 'utf-8', timeout: 10000, stdio: ['pipe', 'pipe', 'pipe'], shell: true, windowsHide: true,
+    }).trim();
+
+    if (raw) {
+      result.containers = raw.split('\n').filter(Boolean).map(line => {
+        const [name, image, status, state] = line.split('\t');
+        return { name, image, status, state };
+      });
+    }
+  } catch { /* docker daemon might not be running */ }
+
+  try {
+    const raw = execSync('docker images -q', {
+      encoding: 'utf-8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'], shell: true, windowsHide: true,
+    }).trim();
+    result.images = raw ? raw.split('\n').length : 0;
+  } catch {}
+
+  try {
+    execSync('docker compose version', { encoding: 'utf-8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'], shell: true, windowsHide: true });
+    result.composeAvailable = true;
+  } catch {}
+
+  return result;
+}
+
+/**
+ * Check if Ollama is signed in and has cloud models available.
+ * Runs `ollama list` and checks for `:cloud` suffix models.
+ */
+function scanOllamaCloud() {
+  return new Promise((resolve) => {
+    exec('ollama list', {
+      encoding: 'utf-8',
+      timeout: 10000,
+      shell: true,
+      windowsHide: true,
+    }, (err, stdout) => {
+      if (err) {
+        return resolve({ signedIn: false, cloudModels: [], localModels: [] });
+      }
+
+      const lines = (stdout || '').trim().split('\n').slice(1); // Skip header
+      const cloudModels = [];
+      const localModels = [];
+
+      for (const line of lines) {
+        const name = line.split(/\s+/)[0];
+        if (!name) continue;
+        if (name.includes(':cloud') || name.includes('-cloud')) {
+          cloudModels.push(name);
+        } else {
+          localModels.push(name);
+        }
+      }
+
+      resolve({
+        signedIn: cloudModels.length > 0 || lines.length > 0,
+        cloudModels,
+        localModels,
+        allModels: [...cloudModels, ...localModels],
+      });
+    });
+  });
+}
+
+/**
+ * Scan all known tools in parallel (async). Much faster than sequential sync scan.
+ * Falls back to sync if called from sync context.
+ */
+async function scanToolsAsync() {
+  const results = await Promise.all(
+    TOOL_DEFINITIONS.map(async (toolDef) => {
+      const result = await checkToolAsync(toolDef);
+      return [toolDef.id, result];
+    })
+  );
+
+  const registry = Object.fromEntries(results);
+  registry._docker = scanDocker();
+
+  // Enrich Ollama entry with cloud model info
+  if (registry.ollama && registry.ollama.installed) {
+    try {
+      const ollamaCloud = await scanOllamaCloud();
+      registry.ollama.cloudModels = ollamaCloud.cloudModels;
+      registry.ollama.localModels = ollamaCloud.localModels;
+      registry.ollama.allModels = ollamaCloud.allModels;
+      registry.ollama.signedIn = ollamaCloud.signedIn;
+      // Flag agenticChat capability
+      registry.ollama.agenticChatCapable = !!(registry.claude && registry.claude.installed);
+    } catch { /* non-critical enrichment */ }
+  }
+
+  return registry;
+}
+
+/**
+ * Scan all known tools (sync fallback — used if async not possible)
+ */
+function scanTools() {
+  const registry = {};
+  for (const toolDef of TOOL_DEFINITIONS) {
+    registry[toolDef.id] = checkTool(toolDef);
+  }
+  registry._docker = scanDocker();
+  return registry;
+}
+
+module.exports = { scanTools, scanToolsAsync, TOOL_DEFINITIONS };

package/src/workspace.js

@@ -0,0 +1,201 @@
+/**
+ * Workspace Manager for Local Agent
+ *
+ * Manages structured workspace directories for agentic AI profiles:
+ *   {root}/Workspace/{profileName}/  — per-profile workspace with CLAUDE.md
+ *   {root}/temp/                     — screenshot/job outputs (auto-cleaned 24h)
+ *   {root}/downloads/                — files from agentic AI (auto-cleaned 7d)
+ *
+ * Two-phase initialization:
+ *   1. On connect: initSharedDirs() creates temp/ and downloads/
+ *   2. On first cliSession: ensureProfileWorkspace() lazily creates profile dir
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+class WorkspaceManager {
+  /**
+   * @param {object} config - Workspace config (merged defaults + user overrides)
+   * @param {string} config.rootPath
+   * @param {number} config.tempMaxAgeMs
+   * @param {number} config.downloadsMaxAgeMs
+   */
+  constructor(config) {
+    this._rootPath = config.rootPath;
+    this._tempMaxAgeMs = config.tempMaxAgeMs;
+    this._downloadsMaxAgeMs = config.downloadsMaxAgeMs;
+    this._activeWorkspaces = new Map(); // profileName → workspacePath
+  }
+
+  getRootPath() {
+    return this._rootPath;
+  }
+
+  getWorkspacePath(profileName) {
+    return path.join(this._rootPath, 'Workspace', sanitizeProfileName(profileName));
+  }
+
+  getTempPath() {
+    return path.join(this._rootPath, 'temp');
+  }
+
+  getDownloadsPath() {
+    return path.join(this._rootPath, 'downloads');
+  }
+
+  /**
+   * Create shared directories (temp, downloads). Called on agent connect.
+   * @returns {{ rootPath: string, tempPath: string, downloadsPath: string }}
+   */
+  initSharedDirs() {
+    const tempPath = this.getTempPath();
+    const downloadsPath = this.getDownloadsPath();
+
+    fs.mkdirSync(tempPath, { recursive: true });
+    fs.mkdirSync(downloadsPath, { recursive: true });
+
+    return {
+      rootPath: this._rootPath,
+      tempPath,
+      downloadsPath,
+    };
+  }
+
+  /**
+   * Lazily create a profile workspace with CLAUDE.md context.
+   * Cached — second call for same profile returns instantly.
+   *
+   * @param {string} profileName
+   * @param {object} [contextData]
+   * @param {string} [contextData.systemPrompt] - Agent system prompt for CLAUDE.md
+   * @returns {string} workspacePath
+   */
+  ensureProfileWorkspace(profileName, contextData = {}) {
+    const sanitized = sanitizeProfileName(profileName);
+    const cached = this._activeWorkspaces.get(sanitized);
+    if (cached) return cached;
+
+    const wsPath = path.join(this._rootPath, 'Workspace', sanitized);
+    fs.mkdirSync(wsPath, { recursive: true });
+
+    // Write/update CLAUDE.md with profile context
+    const claudeMdPath = path.join(wsPath, 'CLAUDE.md');
+    const content = buildClaudeMd(profileName, contextData);
+    fs.writeFileSync(claudeMdPath, content, 'utf-8');
+
+    this._activeWorkspaces.set(sanitized, wsPath);
+    return wsPath;
+  }
+
+  /**
+   * Get cached workspace path for a profile, or null if not yet created.
+   */
+  getWorkspaceForProfile(profileName) {
+    return this._activeWorkspaces.get(sanitizeProfileName(profileName)) || null;
+  }
+
+  /**
+   * Delete files in temp/ older than threshold (default: 24h)
+   */
+  cleanupTemp(maxAgeMs) {
+    const threshold = maxAgeMs ?? this._tempMaxAgeMs;
+    return cleanupDir(this.getTempPath(), threshold);
+  }
+
+  /**
+   * Delete files in downloads/ older than threshold (default: 7d)
+   */
+  cleanupDownloads(maxAgeMs) {
+    const threshold = maxAgeMs ?? this._downloadsMaxAgeMs;
+    return cleanupDir(this.getDownloadsPath(), threshold);
+  }
+}
+
+// =====================================================
+// Helpers
+// =====================================================
+
+/**
+ * Sanitize profile name for use as a folder name.
+ * Replace non-alphanumeric (except - and _) with _, trim, max 50 chars.
+ */
+function sanitizeProfileName(name) {
+  return (name || 'unknown')
+    .replace(/[^a-zA-Z0-9_-]/g, '_')
+    .replace(/_+/g, '_')
+    .replace(/^_|_$/g, '')
+    .substring(0, 50) || 'unknown';
+}
+
+/**
+ * Build CLAUDE.md content for a profile workspace.
+ */
+function buildClaudeMd(profileName, contextData = {}) {
+  const timestamp = new Date().toISOString();
+  const lines = [
+    `# ${profileName} Workspace`,
+    '',
+    `Agent: ${profileName}`,
+    `Initialized: ${timestamp}`,
+    '',
+  ];
+
+  if (contextData.systemPrompt) {
+    lines.push('## Instructions', '', contextData.systemPrompt, '');
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Delete files in a directory older than maxAgeMs.
+ * Skips subdirectories (only cleans top-level files).
+ * @returns {number} Number of files deleted
+ */
+function cleanupDir(dirPath, maxAgeMs) {
+  if (!fs.existsSync(dirPath)) return 0;
+
+  let deleted = 0;
+  const now = Date.now();
+
+  try {
+    const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isFile()) continue;
+      const fullPath = path.join(dirPath, entry.name);
+      try {
+        const stat = fs.statSync(fullPath);
+        if (now - stat.mtimeMs > maxAgeMs) {
+          fs.unlinkSync(fullPath);
+          deleted++;
+        }
+      } catch { /* skip files we can't stat/delete */ }
+    }
+  } catch { /* directory read failed, non-critical */ }
+
+  return deleted;
+}
+
+// =====================================================
+// Singleton
+// =====================================================
+
+let _instance = null;
+
+function getWorkspaceManager() {
+  return _instance;
+}
+
+function initWorkspaceManager(config) {
+  _instance = new WorkspaceManager(config);
+  return _instance;
+}
+
+module.exports = {
+  WorkspaceManager,
+  getWorkspaceManager,
+  initWorkspaceManager,
+  sanitizeProfileName,
+};