@harbinger-ai/harbinger 0.1.2 → 0.1.3

package/lib/chat/actions.js

@@ -271,6 +271,403 @@ export async function deleteApiKey() {
   }
 }
 
+// ─────────────────────────────────────────────────────────────────────────────
+// LLM Provider actions
+// ─────────────────────────────────────────────────────────────────────────────
+
+/**
+ * Get all configured LLM providers from settings table.
+ * @returns {Promise<object>} — { anthropic: { apiKey, model, maxTokens }, ... }
+ */
+export async function getLlmProviders() {
+  await requireAuth();
+  try {
+    const { getDb } = await import('../db/index.js');
+    const { settings } = await import('../db/schema.js');
+    const { eq } = await import('drizzle-orm');
+    const db = getDb();
+    const rows = db.select().from(settings).where(eq(settings.type, 'llm_provider')).all();
+    const result = {};
+    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 : '' };
+      } catch {}
+    }
+    return result;
+  } catch (err) {
+    console.error('Failed to get LLM providers:', err);
+    return {};
+  }
+}
+
+/**
+ * Save/update an LLM provider config.
+ */
+export async function saveLlmProvider(provider, config) {
+  await requireAuth();
+  try {
+    const { getDb } = await import('../db/index.js');
+    const { settings } = await import('../db/schema.js');
+    const { eq, and } = await import('drizzle-orm');
+    const fs = await import('fs');
+    const path = await import('path');
+    const db = getDb();
+
+    // If existing row, read current to preserve apiKey if not changing
+    const existing = db.select().from(settings)
+      .where(and(eq(settings.type, 'llm_provider'), eq(settings.key, provider)))
+      .get();
+
+    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;
+    }
+
+    const value = JSON.stringify(merged);
+    if (existing) {
+      db.update(settings).set({ value }).where(and(eq(settings.type, 'llm_provider'), eq(settings.key, provider))).run();
+    } else {
+      db.insert(settings).values({ type: 'llm_provider', key: provider, value }).run();
+    }
+
+    // Also write to .env for persistence across container restarts
+    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' },
+    };
+    const mapping = envMap[provider];
+    if (mapping && 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}`);
+        } else {
+          envContent += `\n${mapping.key}=${merged.apiKey}`;
+        }
+        fs.writeFileSync(envPath, envContent);
+      } catch (envErr) {
+        console.error('Failed to write .env:', envErr);
+      }
+    }
+
+    return { success: true };
+  } catch (err) {
+    console.error('Failed to save LLM provider:', err);
+    return { error: err.message };
+  }
+}
+
+/**
+ * Set the active provider (writes to .env + settings).
+ */
+export async function setActiveProvider(provider, model) {
+  await requireAuth();
+  try {
+    const { getDb } = await import('../db/index.js');
+    const { settings } = await import('../db/schema.js');
+    const { eq, and } = await import('drizzle-orm');
+    const fs = await import('fs');
+    const path = await import('path');
+    const db = getDb();
+
+    const value = JSON.stringify({ provider, model });
+    const existing = db.select().from(settings)
+      .where(and(eq(settings.type, 'llm_config'), eq(settings.key, 'active_provider')))
+      .get();
+
+    if (existing) {
+      db.update(settings).set({ value }).where(and(eq(settings.type, 'llm_config'), eq(settings.key, 'active_provider'))).run();
+    } else {
+      db.insert(settings).values({ type: 'llm_config', key: 'active_provider', value }).run();
+    }
+
+    // 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 || '' };
+      for (const [envKey, envVal] of Object.entries(updates)) {
+        const pat = new RegExp(`^${envKey}=.*$`, 'm');
+        if (pat.test(envContent)) {
+          envContent = envContent.replace(pat, `${envKey}=${envVal}`);
+        } else {
+          envContent += `\n${envKey}=${envVal}`;
+        }
+      }
+      fs.writeFileSync(envPath, envContent);
+    } catch {}
+
+    // Update process.env for immediate effect
+    process.env.LLM_PROVIDER = provider;
+    if (model) process.env.LLM_MODEL = model;
+
+    return { success: true };
+  } catch (err) {
+    console.error('Failed to set active provider:', err);
+    return { error: err.message };
+  }
+}
+
+/**
+ * Test an LLM provider connection by sending a simple message.
+ */
+export async function testLlmConnection(provider) {
+  await requireAuth();
+  try {
+    const { getDb } = await import('../db/index.js');
+    const { settings } = await import('../db/schema.js');
+    const { eq, and } = await import('drizzle-orm');
+    const db = getDb();
+
+    const row = db.select().from(settings)
+      .where(and(eq(settings.type, 'llm_provider'), eq(settings.key, provider)))
+      .get();
+
+    if (!row) return { error: 'Provider not configured' };
+    const config = JSON.parse(row.value);
+    if (!config.apiKey) return { error: 'No API key configured' };
+
+    // Simple connectivity test using fetch
+    const endpoints = {
+      anthropic: 'https://api.anthropic.com/v1/messages',
+      openai: 'https://api.openai.com/v1/chat/completions',
+      google: `https://generativelanguage.googleapis.com/v1beta/models/${config.model || 'gemini-2.0-flash'}:generateContent?key=${config.apiKey}`,
+      custom: (config.baseUrl || 'https://api.openai.com/v1') + '/chat/completions',
+    };
+
+    if (provider === 'anthropic') {
+      const res = await fetch(endpoints.anthropic, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'x-api-key': config.apiKey,
+          'anthropic-version': '2023-06-01',
+        },
+        body: JSON.stringify({
+          model: config.model || 'claude-sonnet-4-20250514',
+          max_tokens: 32,
+          messages: [{ role: 'user', content: 'Reply with only the word "connected"' }],
+        }),
+      });
+      if (!res.ok) {
+        const body = await res.text();
+        return { error: `HTTP ${res.status}: ${body.slice(0, 200)}` };
+      }
+      const data = await res.json();
+      return { success: true, response: data.content?.[0]?.text || 'OK' };
+    }
+
+    if (provider === 'openai' || provider === 'custom') {
+      const res = await fetch(endpoints[provider], {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${config.apiKey}`,
+        },
+        body: JSON.stringify({
+          model: config.model || 'gpt-4o-mini',
+          max_tokens: 32,
+          messages: [{ role: 'user', content: 'Reply with only the word "connected"' }],
+        }),
+      });
+      if (!res.ok) {
+        const body = await res.text();
+        return { error: `HTTP ${res.status}: ${body.slice(0, 200)}` };
+      }
+      const data = await res.json();
+      return { success: true, response: data.choices?.[0]?.message?.content || 'OK' };
+    }
+
+    if (provider === 'google') {
+      const res = await fetch(endpoints.google, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          contents: [{ parts: [{ text: 'Reply with only the word "connected"' }] }],
+          generationConfig: { maxOutputTokens: 32 },
+        }),
+      });
+      if (!res.ok) {
+        const body = await res.text();
+        return { error: `HTTP ${res.status}: ${body.slice(0, 200)}` };
+      }
+      const data = await res.json();
+      return { success: true, response: data.candidates?.[0]?.content?.parts?.[0]?.text || 'OK' };
+    }
+
+    return { error: 'Unknown provider' };
+  } catch (err) {
+    return { error: err.message };
+  }
+}
+
+/**
+ * Get the current active provider info.
+ */
+export async function getActiveProvider() {
+  await requireAuth();
+  try {
+    const { getDb } = await import('../db/index.js');
+    const { settings } = await import('../db/schema.js');
+    const { eq, and } = await import('drizzle-orm');
+    const db = getDb();
+
+    const row = db.select().from(settings)
+      .where(and(eq(settings.type, 'llm_config'), eq(settings.key, 'active_provider')))
+      .get();
+
+    if (row) return JSON.parse(row.value);
+
+    // Fallback: read from env
+    return {
+      provider: process.env.LLM_PROVIDER || 'anthropic',
+      model: process.env.LLM_MODEL || '',
+    };
+  } catch (err) {
+    return { provider: process.env.LLM_PROVIDER || 'anthropic', model: process.env.LLM_MODEL || '' };
+  }
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Agent management actions
+// ─────────────────────────────────────────────────────────────────────────────
+
+/**
+ * Get all agent profiles with their activity status from swarm.
+ */
+export async function getAgentProfilesWithStatus() {
+  await requireAuth();
+  try {
+    const { discoverAgents } = await import('../agents.js');
+    const agents = discoverAgents();
+
+    // Cross-reference with swarm
+    let runs = [];
+    try {
+      const { getSwarmStatus: fetchStatus } = await import('../tools/github.js');
+      const swarm = await fetchStatus(1);
+      runs = swarm.runs || [];
+    } catch {}
+
+    return agents.map((a) => {
+      const codename = (a.codename || a.name || a.id || '').toLowerCase();
+      const activeRuns = runs.filter(
+        (r) =>
+          (r.status === 'in_progress' || r.status === 'queued') &&
+          (r.branch || '').toLowerCase().includes(codename)
+      );
+      return {
+        ...a,
+        activeJobs: activeRuns.length,
+        status: activeRuns.length > 0 ? 'active' : 'idle',
+      };
+    });
+  } catch (err) {
+    console.error('Failed to get agent profiles with status:', err);
+    return [];
+  }
+}
+
+/**
+ * Get a single agent's full profile (including markdown file content).
+ */
+export async function getAgentProfile(agentId) {
+  await requireAuth();
+  try {
+    const { loadAgentProfile } = await import('../agents.js');
+    return loadAgentProfile(agentId);
+  } catch (err) {
+    console.error('Failed to get agent profile:', err);
+    return null;
+  }
+}
+
+/**
+ * Update an agent's file content (SOUL.md, SKILLS.md, TOOLS.md, IDENTITY.md, CONFIG.yaml).
+ */
+export async function updateAgentFile(agentId, filename, content) {
+  await requireAuth();
+  try {
+    const fs = await import('fs');
+    const path = await import('path');
+    const { agentsDir } = await import('../paths.js');
+    const allowed = ['SOUL.md', 'SKILLS.md', 'TOOLS.md', 'IDENTITY.md', 'CONFIG.yaml', 'HEARTBEAT.md'];
+    if (!allowed.includes(filename)) return { error: 'File not allowed' };
+    const filePath = path.join(agentsDir, agentId, filename);
+    fs.writeFileSync(filePath, content, 'utf8');
+    return { success: true };
+  } catch (err) {
+    console.error('Failed to update agent file:', err);
+    return { error: err.message };
+  }
+}
+
+/**
+ * Create a new agent with identity files.
+ */
+export async function createAgent(identity) {
+  await requireAuth();
+  try {
+    const fs = await import('fs');
+    const path = await import('path');
+    const { agentsDir } = await import('../paths.js');
+    const dirName = (identity.name || identity.codename || 'new-agent').toLowerCase().replace(/[^a-z0-9-]/g, '-');
+    const agentPath = path.join(agentsDir, dirName);
+
+    if (fs.existsSync(agentPath)) return { error: 'Agent directory already exists' };
+    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');
+
+    // 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');
+
+    return { success: true, id: dirName };
+  } catch (err) {
+    console.error('Failed to create agent:', err);
+    return { error: err.message };
+  }
+}
+
+/**
+ * Create a job for a specific agent.
+ */
+export async function createAgentJob(agentId, prompt) {
+  await requireAuth();
+  try {
+    const { createJob } = await import('../tools/github.js');
+    // Prefix the prompt with agent mention
+    const { loadAgentProfile } = await import('../agents.js');
+    const profile = loadAgentProfile(agentId);
+    const codename = profile?.codename || agentId;
+    const fullPrompt = `@${codename.toUpperCase()} ${prompt}`;
+    const result = await createJob(fullPrompt);
+    return { success: true, ...result };
+  } catch (err) {
+    console.error('Failed to create agent job:', err);
+    return { error: err.message };
+  }
+}
+
 // ─────────────────────────────────────────────────────────────────────────────
 // Swarm actions
 // ─────────────────────────────────────────────────────────────────────────────