@harbinger-ai/harbinger 0.1.3 → 0.1.4

package/lib/bounty/actions.js

@@ -98,6 +98,51 @@ export async function getFindingCounts() {
   return dbCounts();
 }
 
+// ── Target Counts ───────────────────────────────────────────────────────────
+
+export async function getProgramTargetCounts() {
+  await requireAuth();
+  const { getDb } = await import('../db/index.js');
+  const db = getDb();
+  const rows = db.prepare(`
+    SELECT program_id, COUNT(*) as total,
+      SUM(CASE WHEN status = 'in_scope' THEN 1 ELSE 0 END) as in_scope,
+      SUM(CASE WHEN status = 'out_of_scope' THEN 1 ELSE 0 END) as out_of_scope
+    FROM targets WHERE program_id IS NOT NULL
+    GROUP BY program_id
+  `).all();
+  const counts = {};
+  for (const r of rows) {
+    counts[r.program_id] = { total: r.total, inScope: r.in_scope, outOfScope: r.out_of_scope };
+  }
+  return counts;
+}
+
+export async function bulkImportTargets(programId, items) {
+  await requireAuth();
+  if (!programId || !Array.isArray(items) || items.length === 0) return { imported: 0 };
+  const { createTarget: dbCreate } = await import('./targets.js');
+  let imported = 0;
+  for (const item of items) {
+    if (!item.value) continue;
+    dbCreate({
+      programId,
+      type: item.type || 'domain',
+      value: item.value.trim(),
+      status: item.status || 'in_scope',
+      notes: item.notes || null,
+    });
+    imported++;
+  }
+  return { imported };
+}
+
+export async function exportTargets(programId) {
+  await requireAuth();
+  const { getTargets: dbGet } = await import('./targets.js');
+  return dbGet(programId);
+}
+
 // ── Target Sync ─────────────────────────────────────────────────────────────
 
 export async function syncTargetsFromPlatform(platform, options = {}) {

package/lib/chat/actions.js

@@ -291,8 +291,11 @@ export async function getLlmProviders() {
     for (const row of rows) {
       try {
         const val = JSON.parse(row.value);
-        // Mask the API key for client display
-        result[row.key] = { ...val, apiKey: val.apiKey ? val.apiKey : '' };
+        // Mask the API key for client — show first 8 + last 4 chars
+        const masked = val.apiKey
+          ? val.apiKey.slice(0, 8) + '***' + val.apiKey.slice(-4)
+          : '';
+        result[row.key] = { ...val, apiKey: masked, hasKey: !!val.apiKey };
       } catch {}
     }
     return result;
@@ -323,8 +326,10 @@ export async function saveLlmProvider(provider, config) {
     let merged = { ...config };
     if (existing) {
       const prev = JSON.parse(existing.value);
-      // If apiKey looks masked or empty, keep existing
-      if (!config.apiKey && prev.apiKey) merged.apiKey = prev.apiKey;
+      // If apiKey looks masked (contains ***) or empty, keep existing
+      if ((!config.apiKey || config.apiKey.includes('***')) && prev.apiKey) {
+        merged.apiKey = prev.apiKey;
+      }
     }
 
     const value = JSON.stringify(merged);
@@ -334,20 +339,32 @@ export async function saveLlmProvider(provider, config) {
       db.insert(settings).values({ type: 'llm_provider', key: provider, value }).run();
     }
 
-    // Also write to .env for persistence across container restarts
+    // Map provider → env var names
     const envMap = {
-      anthropic: { key: 'ANTHROPIC_API_KEY', model: 'LLM_MODEL', provider: 'anthropic' },
-      openai: { key: 'OPENAI_API_KEY', model: 'LLM_MODEL', provider: 'openai' },
-      google: { key: 'GOOGLE_API_KEY', model: 'LLM_MODEL', provider: 'google' },
-      custom: { key: 'CUSTOM_API_KEY', model: 'LLM_MODEL', provider: 'custom' },
+      anthropic: { key: 'ANTHROPIC_API_KEY' },
+      openai:    { key: 'OPENAI_API_KEY' },
+      google:    { key: 'GOOGLE_API_KEY' },
+      custom:    { key: 'CUSTOM_API_KEY' },
+      ollama:    { key: null },
+      lmstudio:  { key: null },
     };
     const mapping = envMap[provider];
-    if (mapping && merged.apiKey) {
+
+    // CRITICAL: Update process.env so the running process can use the key immediately
+    if (mapping?.key && merged.apiKey) {
+      process.env[mapping.key] = merged.apiKey;
+    }
+    // For local providers, set the base URL in process.env
+    if (merged.baseUrl) {
+      process.env.OPENAI_BASE_URL = merged.baseUrl;
+    }
+
+    // Write to .env for persistence across container restarts
+    if (mapping?.key && merged.apiKey) {
       try {
         const envPath = path.join(process.cwd(), '.env');
         let envContent = '';
         try { envContent = fs.readFileSync(envPath, 'utf8'); } catch {}
-        // Update or append the API key line
         const keyPattern = new RegExp(`^${mapping.key}=.*$`, 'm');
         if (keyPattern.test(envContent)) {
           envContent = envContent.replace(keyPattern, `${mapping.key}=${merged.apiKey}`);
@@ -359,6 +376,21 @@ export async function saveLlmProvider(provider, config) {
         console.error('Failed to write .env:', envErr);
       }
     }
+    // Also persist base URL for local providers
+    if (merged.baseUrl) {
+      try {
+        const envPath = path.join(process.cwd(), '.env');
+        let envContent = '';
+        try { envContent = fs.readFileSync(envPath, 'utf8'); } catch {}
+        const pat = /^OPENAI_BASE_URL=.*$/m;
+        if (pat.test(envContent)) {
+          envContent = envContent.replace(pat, `OPENAI_BASE_URL=${merged.baseUrl}`);
+        } else {
+          envContent += `\nOPENAI_BASE_URL=${merged.baseUrl}`;
+        }
+        fs.writeFileSync(envPath, envContent);
+      } catch {}
+    }
 
     return { success: true };
   } catch (err) {
@@ -380,6 +412,9 @@ export async function setActiveProvider(provider, model) {
     const path = await import('path');
     const db = getDb();
 
+    // For local providers (ollama, lmstudio), map to 'custom' for model.js
+    const effectiveProvider = (provider === 'ollama' || provider === 'lmstudio') ? 'custom' : provider;
+
     const value = JSON.stringify({ provider, model });
     const existing = db.select().from(settings)
       .where(and(eq(settings.type, 'llm_config'), eq(settings.key, 'active_provider')))
@@ -391,13 +426,52 @@ export async function setActiveProvider(provider, model) {
       db.insert(settings).values({ type: 'llm_config', key: 'active_provider', value }).run();
     }
 
+    // Also read the provider's API key from DB and apply it to process.env
+    const provRow = db.select().from(settings)
+      .where(and(eq(settings.type, 'llm_provider'), eq(settings.key, provider)))
+      .get();
+
+    const envKeyMap = {
+      anthropic: 'ANTHROPIC_API_KEY',
+      openai: 'OPENAI_API_KEY',
+      google: 'GOOGLE_API_KEY',
+      custom: 'CUSTOM_API_KEY',
+    };
+
+    if (provRow) {
+      const provConfig = JSON.parse(provRow.value);
+      const envKey = envKeyMap[effectiveProvider];
+      if (envKey && provConfig.apiKey) {
+        process.env[envKey] = provConfig.apiKey;
+      }
+      // Set base URL for local/custom providers
+      if (provConfig.baseUrl) {
+        process.env.OPENAI_BASE_URL = provConfig.baseUrl;
+      } else if (provider === 'ollama') {
+        process.env.OPENAI_BASE_URL = 'http://host.docker.internal:11434/v1';
+      } else if (provider === 'lmstudio') {
+        process.env.OPENAI_BASE_URL = 'http://host.docker.internal:1234/v1';
+      } else {
+        // Cloud provider — clear any local base URL
+        delete process.env.OPENAI_BASE_URL;
+      }
+    }
+
     // Write to .env
     try {
       const envPath = path.join(process.cwd(), '.env');
       let envContent = '';
       try { envContent = fs.readFileSync(envPath, 'utf8'); } catch {}
 
-      const updates = { LLM_PROVIDER: provider, LLM_MODEL: model || '' };
+      const updates = { LLM_PROVIDER: effectiveProvider, LLM_MODEL: model || '' };
+
+      // For local providers set the base URL
+      if (provider === 'ollama') {
+        updates.OPENAI_BASE_URL = 'http://host.docker.internal:11434/v1';
+      } else if (provider === 'lmstudio') {
+        updates.OPENAI_BASE_URL = 'http://host.docker.internal:1234/v1';
+      }
+
       for (const [envKey, envVal] of Object.entries(updates)) {
         const pat = new RegExp(`^${envKey}=.*$`, 'm');
         if (pat.test(envContent)) {
@@ -410,7 +484,7 @@ export async function setActiveProvider(provider, model) {
     } catch {}
 
     // Update process.env for immediate effect
-    process.env.LLM_PROVIDER = provider;
+    process.env.LLM_PROVIDER = effectiveProvider;
     if (model) process.env.LLM_MODEL = model;
 
     return { success: true };
@@ -420,6 +494,122 @@ export async function setActiveProvider(provider, model) {
   }
 }
 
+/**
+ * Scan for locally running LLM providers (Ollama, LM Studio, etc.)
+ * Returns array of detected providers with their models.
+ */
+export async function scanLocalProviders() {
+  await requireAuth();
+  const results = [];
+
+  // Known local provider endpoints
+  const localEndpoints = [
+    { id: 'ollama', name: 'Ollama', urls: ['http://localhost:11434', 'http://host.docker.internal:11434'], modelsPath: '/api/tags' },
+    { id: 'lmstudio', name: 'LM Studio', urls: ['http://localhost:1234/v1', 'http://host.docker.internal:1234/v1'], modelsPath: '/models' },
+    { id: 'localai', name: 'LocalAI', urls: ['http://localhost:8080/v1', 'http://host.docker.internal:8080/v1'], modelsPath: '/models' },
+    { id: 'llamacpp', name: 'llama.cpp', urls: ['http://localhost:8081', 'http://host.docker.internal:8081'], modelsPath: '/v1/models' },
+    { id: 'vllm', name: 'vLLM', urls: ['http://localhost:8000/v1', 'http://host.docker.internal:8000/v1'], modelsPath: '/models' },
+    { id: 'jan', name: 'Jan', urls: ['http://localhost:1337/v1', 'http://host.docker.internal:1337/v1'], modelsPath: '/models' },
+  ];
+
+  for (const endpoint of localEndpoints) {
+    for (const baseUrl of endpoint.urls) {
+      try {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 3000);
+        const url = baseUrl.replace(/\/v1$/, '') + endpoint.modelsPath;
+        const res = await fetch(url, { signal: controller.signal });
+        clearTimeout(timeout);
+
+        if (res.ok) {
+          const data = await res.json();
+          let models = [];
+
+          // Parse models based on provider format
+          if (endpoint.id === 'ollama') {
+            models = (data.models || []).map(m => ({
+              id: m.name || m.model,
+              name: m.name || m.model,
+              size: m.size,
+              modified: m.modified_at,
+              family: m.details?.family,
+              paramSize: m.details?.parameter_size,
+              quantization: m.details?.quantization_level,
+            }));
+          } else {
+            // OpenAI-compatible format
+            models = (data.data || data || []).map(m => ({
+              id: m.id,
+              name: m.id,
+              owned_by: m.owned_by,
+            }));
+          }
+
+          results.push({
+            id: endpoint.id,
+            name: endpoint.name,
+            baseUrl: baseUrl,
+            available: true,
+            models,
+          });
+          break; // Found this provider, skip remaining URLs
+        }
+      } catch {
+        // Not available at this URL, try next
+      }
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Get models from a specific local provider endpoint.
+ */
+export async function getLocalModels(providerUrl) {
+  await requireAuth();
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 5000);
+
+    // Try Ollama format first
+    let url = providerUrl.replace(/\/v1$/, '') + '/api/tags';
+    let res = await fetch(url, { signal: controller.signal }).catch(() => null);
+
+    if (res?.ok) {
+      clearTimeout(timeout);
+      const data = await res.json();
+      return (data.models || []).map(m => ({
+        id: m.name || m.model,
+        name: m.name || m.model,
+        size: m.size,
+        family: m.details?.family,
+        paramSize: m.details?.parameter_size,
+      }));
+    }
+
+    // Try OpenAI-compatible format
+    url = providerUrl.replace(/\/$/, '') + (providerUrl.includes('/v1') ? '' : '/v1') + '/models';
+    const controller2 = new AbortController();
+    const timeout2 = setTimeout(() => controller2.abort(), 5000);
+    res = await fetch(url, { signal: controller2.signal }).catch(() => null);
+    clearTimeout(timeout2);
+
+    if (res?.ok) {
+      const data = await res.json();
+      return (data.data || data || []).map(m => ({
+        id: m.id,
+        name: m.id,
+        owned_by: m.owned_by,
+      }));
+    }
+
+    return [];
+  } catch {
+    return [];
+  }
+}
+
 /**
  * Test an LLM provider connection by sending a simple message.
  */
@@ -507,6 +697,37 @@ export async function testLlmConnection(provider) {
       return { success: true, response: data.candidates?.[0]?.content?.parts?.[0]?.text || 'OK' };
     }
 
+    // Local providers (Ollama, LM Studio, etc.) — test via OpenAI-compatible endpoint
+    if (provider === 'ollama' || provider === 'lmstudio' || provider === 'localai' || provider === 'llamacpp' || provider === 'vllm' || provider === 'jan') {
+      const baseUrls = {
+        ollama: 'http://host.docker.internal:11434/v1',
+        lmstudio: 'http://host.docker.internal:1234/v1',
+        localai: 'http://host.docker.internal:8080/v1',
+        llamacpp: 'http://host.docker.internal:8081/v1',
+        vllm: 'http://host.docker.internal:8000/v1',
+        jan: 'http://host.docker.internal:1337/v1',
+      };
+      const base = config.baseUrl || baseUrls[provider] || baseUrls.ollama;
+      const testModel = config.model || 'llama3';
+
+      // First try to just list models (lightweight check)
+      try {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 5000);
+        const modelsUrl = base.replace(/\/v1$/, '') + (provider === 'ollama' ? '/api/tags' : '/models');
+        const modelsRes = await fetch(modelsUrl, { signal: controller.signal });
+        clearTimeout(timeout);
+        if (modelsRes.ok) {
+          const data = await modelsRes.json();
+          const count = data.models?.length || data.data?.length || 0;
+          return { success: true, response: `Connected. ${count} model(s) available.` };
+        }
+        return { error: `Cannot reach ${provider} at ${base}` };
+      } catch (e) {
+        return { error: `Cannot reach ${provider}: ${e.message}` };
+      }
+    }
+
     return { error: 'Unknown provider' };
   } catch (err) {
     return { error: err.message };
@@ -528,12 +749,28 @@ export async function getActiveProvider() {
       .where(and(eq(settings.type, 'llm_config'), eq(settings.key, 'active_provider')))
       .get();
 
-    if (row) return JSON.parse(row.value);
+    if (row) {
+      const active = JSON.parse(row.value);
+      // Also return whether the API key is loaded in process.env
+      const envKey = {
+        anthropic: 'ANTHROPIC_API_KEY',
+        openai: 'OPENAI_API_KEY',
+        google: 'GOOGLE_API_KEY',
+        custom: 'CUSTOM_API_KEY',
+      }[active.provider === 'ollama' || active.provider === 'lmstudio' ? 'custom' : active.provider];
+      active.keyLoaded = envKey ? !!process.env[envKey] : true;
+      active.envProvider = process.env.LLM_PROVIDER;
+      active.envModel = process.env.LLM_MODEL;
+      return active;
+    }
 
     // Fallback: read from env
     return {
       provider: process.env.LLM_PROVIDER || 'anthropic',
       model: process.env.LLM_MODEL || '',
+      keyLoaded: !!process.env.ANTHROPIC_API_KEY,
+      envProvider: process.env.LLM_PROVIDER,
+      envModel: process.env.LLM_MODEL,
     };
   } catch (err) {
     return { provider: process.env.LLM_PROVIDER || 'anthropic', model: process.env.LLM_MODEL || '' };
@@ -615,7 +852,7 @@ export async function updateAgentFile(agentId, filename, content) {
 }
 
 /**
- * Create a new agent with identity files.
+ * Create a new agent with identity files and optional extended configuration.
  */
 export async function createAgent(identity) {
   await requireAuth();
@@ -630,16 +867,83 @@ export async function createAgent(identity) {
     fs.mkdirSync(agentPath, { recursive: true });
 
     // IDENTITY.md
-    const identityContent = `Name: ${identity.name || dirName}\nCodename: ${identity.codename || dirName.toUpperCase()}\nRole: ${identity.role || 'General Agent'}\nSpecialization: ${identity.specialization || 'General'}`;
-    fs.writeFileSync(path.join(agentPath, 'IDENTITY.md'), identityContent, 'utf8');
+    const identityLines = [
+      `Name: ${identity.name || dirName}`,
+      `Codename: ${identity.codename || dirName.toUpperCase()}`,
+      `Role: ${identity.role || 'General Agent'}`,
+      `Specialization: ${identity.specialization || 'General'}`,
+    ];
+    if (identity.description) identityLines.push(`Description: ${identity.description}`);
+    if (identity.tags?.length) identityLines.push(`Tags: ${identity.tags.join(', ')}`);
+    if (identity.goal) identityLines.push(`Goal: ${identity.goal}`);
+    fs.writeFileSync(path.join(agentPath, 'IDENTITY.md'), identityLines.join('\n'), 'utf8');
 
     // SOUL.md
     const soulContent = identity.soul || `# ${identity.codename || dirName.toUpperCase()}\n\nYou are ${identity.name || dirName}, a specialized AI agent.\n\n## Role\n${identity.role || 'General Agent'}\n\n## Specialization\n${identity.specialization || 'General purpose tasks'}`;
     fs.writeFileSync(path.join(agentPath, 'SOUL.md'), soulContent, 'utf8');
 
-    // CONFIG.yaml
-    const configContent = `codename: ${identity.codename || dirName.toUpperCase()}\nrole: ${identity.role || 'General Agent'}\nactive: true`;
-    fs.writeFileSync(path.join(agentPath, 'CONFIG.yaml'), configContent, 'utf8');
+    // SKILLS.md
+    if (identity.skills) {
+      fs.writeFileSync(path.join(agentPath, 'SKILLS.md'), identity.skills, 'utf8');
+    }
+
+    // TOOLS.md
+    if (identity.tools) {
+      fs.writeFileSync(path.join(agentPath, 'TOOLS.md'), identity.tools, 'utf8');
+    }
+
+    // HEARTBEAT.md
+    if (identity.heartbeat) {
+      fs.writeFileSync(path.join(agentPath, 'HEARTBEAT.md'), identity.heartbeat, 'utf8');
+    }
+
+    // CONFIG.yaml — extended with LLM, scheduling, resources
+    const configLines = [
+      `codename: ${identity.codename || dirName.toUpperCase()}`,
+      `role: ${identity.role || 'General Agent'}`,
+      `active: true`,
+    ];
+    if (identity.llm) {
+      configLines.push(`\n# LLM Configuration`);
+      if (identity.llm.provider) configLines.push(`llm_provider: ${identity.llm.provider}`);
+      if (identity.llm.model) configLines.push(`llm_model: ${identity.llm.model}`);
+      if (identity.llm.temperature != null) configLines.push(`llm_temperature: ${identity.llm.temperature}`);
+      if (identity.llm.maxTokens) configLines.push(`llm_max_tokens: ${identity.llm.maxTokens}`);
+    }
+    if (identity.scheduling) {
+      configLines.push(`\n# Scheduling`);
+      if (identity.scheduling.mode) configLines.push(`run_mode: ${identity.scheduling.mode}`);
+      if (identity.scheduling.schedule) configLines.push(`schedule: "${identity.scheduling.schedule}"`);
+      if (identity.scheduling.maxConcurrent) configLines.push(`max_concurrent: ${identity.scheduling.maxConcurrent}`);
+      if (identity.scheduling.timeout) configLines.push(`timeout: ${identity.scheduling.timeout}`);
+    }
+    if (identity.resources) {
+      configLines.push(`\n# Resources`);
+      if (identity.resources.cpu) configLines.push(`cpu: ${identity.resources.cpu}`);
+      if (identity.resources.memory) configLines.push(`memory: "${identity.resources.memory}"`);
+      if (identity.resources.disk) configLines.push(`disk: "${identity.resources.disk}"`);
+      if (identity.resources.network) configLines.push(`network: ${identity.resources.network}`);
+    }
+    if (identity.envVars && Object.keys(identity.envVars).length > 0) {
+      configLines.push(`\n# Environment Variables`);
+      configLines.push(`env:`);
+      for (const [k, v] of Object.entries(identity.envVars)) {
+        configLines.push(`  ${k}: "${v}"`);
+      }
+    }
+    if (identity.mcpTools?.length) {
+      configLines.push(`\n# MCP Tools`);
+      configLines.push(`tools:`);
+      for (const t of identity.mcpTools) {
+        configLines.push(`  - ${t}`);
+      }
+    }
+    if (identity.team) {
+      configLines.push(`\n# Team`);
+      if (identity.team.swarm) configLines.push(`swarm: ${identity.team.swarm}`);
+      if (identity.team.supervisor) configLines.push(`supervisor: ${identity.team.supervisor}`);
+    }
+    fs.writeFileSync(path.join(agentPath, 'CONFIG.yaml'), configLines.join('\n'), 'utf8');
 
     return { success: true, id: dirName };
   } catch (err) {
@@ -648,6 +952,20 @@ export async function createAgent(identity) {
   }
 }
 
+/**
+ * Get available MCP tool names for agent tool assignment.
+ */
+export async function getAvailableMcpTools() {
+  await requireAuth();
+  try {
+    const { loadMcpTools } = await import('../mcp/client.js');
+    const tools = await loadMcpTools();
+    return tools.map(t => ({ name: t.name, description: t.description }));
+  } catch {
+    return [];
+  }
+}
+
 /**
  * Create a job for a specific agent.
  */