@harbinger-ai/harbinger 0.1.0

package/drizzle/meta/_journal.json

@@ -0,0 +1,34 @@
+{
+  "version": "7",
+  "dialect": "sqlite",
+  "entries": [
+    {
+      "idx": 0,
+      "version": "6",
+      "when": 1771448716757,
+      "tag": "0000_initial",
+      "breakpoints": true
+    },
+    {
+      "idx": 1,
+      "version": "6",
+      "when": 1772228400000,
+      "tag": "0001_bounty_and_registry",
+      "breakpoints": true
+    },
+    {
+      "idx": 2,
+      "version": "6",
+      "when": 1772315400000,
+      "tag": "0002_sync_columns",
+      "breakpoints": true
+    },
+    {
+      "idx": 3,
+      "version": "6",
+      "when": 1772287739089,
+      "tag": "0003_graceful_bloodscream",
+      "breakpoints": true
+    }
+  ]
+}

package/drizzle/relations.ts

@@ -0,0 +1,3 @@
+import { relations } from "drizzle-orm/relations";
+import {  } from "./schema";
+

package/drizzle/schema.ts

@@ -0,0 +1,145 @@
+import { sqliteTable, AnySQLiteColumn, text, integer, uniqueIndex } from "drizzle-orm/sqlite-core"
+  import { sql } from "drizzle-orm"
+
+export const programs = sqliteTable("programs", {
+	id: text().primaryKey().notNull(),
+	name: text().notNull(),
+	platform: text().default("custom").notNull(),
+	url: text(),
+	scopeUrl: text("scope_url"),
+	minBounty: integer("min_bounty"),
+	maxBounty: integer("max_bounty"),
+	status: text().default("active").notNull(),
+	notes: text(),
+	createdAt: integer("created_at").notNull(),
+	updatedAt: integer("updated_at").notNull(),
+	syncHandle: text("sync_handle"),
+	lastSyncedAt: integer("last_synced_at"),
+});
+
+export const targets = sqliteTable("targets", {
+	id: text().primaryKey().notNull(),
+	programId: text("program_id"),
+	type: text().default("domain").notNull(),
+	value: text().notNull(),
+	status: text().default("in_scope").notNull(),
+	technologies: text(),
+	notes: text(),
+	lastScannedAt: integer("last_scanned_at"),
+	createdAt: integer("created_at").notNull(),
+	updatedAt: integer("updated_at").notNull(),
+	syncSource: text("sync_source"),
+	syncProgramHandle: text("sync_program_handle"),
+});
+
+export const findings = sqliteTable("findings", {
+	id: text().primaryKey().notNull(),
+	targetId: text("target_id"),
+	title: text().notNull(),
+	severity: text().default("info").notNull(),
+	type: text().notNull(),
+	status: text().default("new").notNull(),
+	description: text(),
+	stepsToReproduce: text("steps_to_reproduce"),
+	impact: text(),
+	evidence: text(),
+	bountyAmount: integer("bounty_amount"),
+	reportUrl: text("report_url"),
+	agentId: text("agent_id"),
+	toolId: text("tool_id"),
+	rawOutput: text("raw_output"),
+	reportedAt: integer("reported_at"),
+	createdAt: integer("created_at").notNull(),
+	updatedAt: integer("updated_at").notNull(),
+});
+
+export const tools = sqliteTable("tools", {
+	id: text().primaryKey().notNull(),
+	catalogId: text("catalog_id"),
+	name: text().notNull(),
+	slug: text().notNull(),
+	category: text().notNull(),
+	description: text(),
+	dockerImage: text("docker_image"),
+	installCmd: text("install_cmd"),
+	sourceUrl: text("source_url"),
+	version: text(),
+	installed: integer().default(0).notNull(),
+	enabled: integer().default(1).notNull(),
+	config: text(),
+	mcpServerId: text("mcp_server_id"),
+	createdAt: integer("created_at").notNull(),
+	updatedAt: integer("updated_at").notNull(),
+},
+(table) => [
+	uniqueIndex("tools_slug_unique").on(table.slug),
+]);
+
+export const dockerContainers = sqliteTable("docker_containers", {
+	id: text().primaryKey().notNull(),
+	toolId: text("tool_id"),
+	containerId: text("container_id"),
+	imageName: text("image_name").notNull(),
+	status: text().default("created").notNull(),
+	agentId: text("agent_id"),
+	ports: text(),
+	env: text(),
+	logs: text(),
+	createdAt: integer("created_at").notNull(),
+	stoppedAt: integer("stopped_at"),
+});
+
+export const chats = sqliteTable("chats", {
+	id: text().primaryKey().notNull(),
+	userId: text("user_id").notNull(),
+	title: text().default("New Chat").notNull(),
+	starred: integer().default(0).notNull(),
+	createdAt: integer("created_at").notNull(),
+	updatedAt: integer("updated_at").notNull(),
+});
+
+export const messages = sqliteTable("messages", {
+	id: text().primaryKey().notNull(),
+	chatId: text("chat_id").notNull(),
+	role: text().notNull(),
+	content: text().notNull(),
+	createdAt: integer("created_at").notNull(),
+});
+
+export const notifications = sqliteTable("notifications", {
+	id: text().primaryKey().notNull(),
+	notification: text().notNull(),
+	payload: text().notNull(),
+	read: integer().default(0).notNull(),
+	createdAt: integer("created_at").notNull(),
+});
+
+export const settings = sqliteTable("settings", {
+	id: text().primaryKey().notNull(),
+	type: text().notNull(),
+	key: text().notNull(),
+	value: text().notNull(),
+	createdBy: text("created_by"),
+	createdAt: integer("created_at").notNull(),
+	updatedAt: integer("updated_at").notNull(),
+});
+
+export const subscriptions = sqliteTable("subscriptions", {
+	id: text().primaryKey().notNull(),
+	platform: text().notNull(),
+	channelId: text("channel_id").notNull(),
+	createdAt: integer("created_at").notNull(),
+});
+
+export const users = sqliteTable("users", {
+	id: text().primaryKey().notNull(),
+	email: text().notNull(),
+	passwordHash: text("password_hash").notNull(),
+	role: text().default("admin").notNull(),
+	createdAt: integer("created_at").notNull(),
+	updatedAt: integer("updated_at").notNull(),
+},
+(table) => [
+	uniqueIndex("users_email_unique").on(table.email),
+]);
+

package/lib/actions.js

@@ -0,0 +1,47 @@
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { createJob } from './tools/create-job.js';
+
+const execAsync = promisify(exec);
+
+/**
+ * Execute a single action
+ * @param {Object} action - { type, job, command, url, method, headers, vars } (type: agent|command|webhook)
+ * @param {Object} opts - { cwd, data }
+ * @returns {Promise<string>} Result description for logging
+ */
+async function executeAction(action, opts = {}) {
+  const type = action.type || 'agent';
+
+  if (type === 'command') {
+    const { stdout, stderr } = await execAsync(action.command, {
+      cwd: opts.cwd,
+      timeout: 30000,
+    });
+    return (stdout || stderr || '').trim();
+  }
+
+  if (type === 'webhook') {
+    const method = (action.method || 'POST').toUpperCase();
+    const headers = { 'Content-Type': 'application/json', ...action.headers };
+    const fetchOpts = { method, headers };
+
+    if (method !== 'GET') {
+      const body = { ...action.vars };
+      if (opts.data) body.data = opts.data;
+      fetchOpts.body = JSON.stringify(body);
+    }
+
+    const res = await fetch(action.url, fetchOpts);
+    return `${method} ${action.url} → ${res.status}`;
+  }
+
+  // Default: agent
+  const options = {};
+  if (action.llm_provider) options.llmProvider = action.llm_provider;
+  if (action.llm_model) options.llmModel = action.llm_model;
+  const result = await createJob(action.job, options);
+  return `job ${result.job_id} — ${result.title}`;
+}
+
+export { executeAction };

package/lib/agents.js

@@ -0,0 +1,166 @@
+import fs from 'fs';
+import path from 'path';
+import { agentsDir } from './paths.js';
+
+const SKIP_DIRS = ['shared', '_template', 'node_modules'];
+
+/**
+ * Parse flat YAML (key: value per line, simple arrays with [a, b]).
+ * No external yaml dependency needed — CONFIG.yaml files are flat key-value.
+ */
+function parseSimpleYaml(content) {
+  const result = {};
+  for (const line of content.split('\n')) {
+    const trimmed = line.split('#')[0].trim(); // strip comments
+    if (!trimmed || trimmed.startsWith('-')) continue;
+
+    const colonIdx = trimmed.indexOf(':');
+    if (colonIdx === -1) continue;
+
+    const key = trimmed.slice(0, colonIdx).trim();
+    let value = trimmed.slice(colonIdx + 1).trim();
+
+    // Parse arrays: [a, b, c]
+    if (value.startsWith('[') && value.endsWith(']')) {
+      value = value.slice(1, -1).split(',').map(v => v.trim()).filter(Boolean);
+    }
+    // Parse numbers
+    else if (/^\d+(\.\d+)?$/.test(value)) {
+      value = parseFloat(value);
+    }
+    // Parse booleans
+    else if (value === 'true') value = true;
+    else if (value === 'false') value = false;
+
+    result[key] = value;
+  }
+  return result;
+}
+
+/**
+ * Parse IDENTITY.md into structured fields.
+ * Supports multiple formats:
+ * - Single-line: "Name: X. Codename: Y. Role: Z. Specialization: W."
+ * - Multi-line: "Name: X\nCodename: Y\nRole: Z\n..."
+ * - Markdown: "**Codename:** X\n**Role:** Y\n..."
+ */
+function parseIdentity(content) {
+  const identity = {};
+  const text = content.trim();
+  const fields = ['name', 'codename', 'role', 'specialization'];
+
+  // Extract each field by scanning the full text with a regex
+  // This handles both single-line ("Name: X. Codename: Y.") and multi-line formats
+  for (const field of fields) {
+    // Match "Field: value" or "**Field:** value" (case-insensitive)
+    // Value ends at next field label, period-space-capital, newline, or end of string
+    const pattern = new RegExp(
+      `\\*{0,2}${field}\\*{0,2}[:\\s]+\\s*(.+?)(?=\\s*\\.\\s*(?:Name|Codename|Role|Specialization)\\b|\\n|$)`,
+      'i'
+    );
+    const match = text.match(pattern);
+    if (match) {
+      identity[field] = match[1].trim().replace(/\.$/, '').replace(/^\*+\s*/, '').replace(/\s*\*+$/, '');
+    }
+  }
+
+  // Fallback for markdown title: "# MAINTAINER — Code Quality Specialist"
+  if (!identity.codename) {
+    const titleMatch = text.match(/^#\s+(\w+)\s+[—–-]\s+(.+)/m);
+    if (titleMatch) {
+      identity.codename = titleMatch[1].trim();
+      if (!identity.role) identity.role = titleMatch[2].trim();
+    }
+  }
+
+  return identity;
+}
+
+/**
+ * Load a single agent profile by directory name.
+ * Returns null if the directory doesn't exist or is invalid.
+ */
+export function loadAgentProfile(agentDirName) {
+  const agentPath = path.join(agentsDir, agentDirName);
+
+  if (!fs.existsSync(agentPath)) return null;
+  const stat = fs.statSync(agentPath);
+  if (!stat.isDirectory()) return null;
+
+  const profile = { id: agentDirName };
+
+  // IDENTITY.md
+  const identityPath = path.join(agentPath, 'IDENTITY.md');
+  if (fs.existsSync(identityPath)) {
+    const identityContent = fs.readFileSync(identityPath, 'utf8');
+    Object.assign(profile, parseIdentity(identityContent));
+  }
+
+  // CONFIG.yaml
+  const configPath = path.join(agentPath, 'CONFIG.yaml');
+  if (fs.existsSync(configPath)) {
+    const configContent = fs.readFileSync(configPath, 'utf8');
+    profile.config = parseSimpleYaml(configContent);
+  }
+
+  // SOUL.md (raw content — used as system prompt)
+  const soulPath = path.join(agentPath, 'SOUL.md');
+  if (fs.existsSync(soulPath)) {
+    profile.soul = fs.readFileSync(soulPath, 'utf8');
+  }
+
+  // SKILLS.md
+  const skillsPath = path.join(agentPath, 'SKILLS.md');
+  if (fs.existsSync(skillsPath)) {
+    profile.skills = fs.readFileSync(skillsPath, 'utf8');
+  }
+
+  // TOOLS.md
+  const toolsPath = path.join(agentPath, 'TOOLS.md');
+  if (fs.existsSync(toolsPath)) {
+    profile.tools = fs.readFileSync(toolsPath, 'utf8');
+  }
+
+  // HEARTBEAT.md
+  const heartbeatPath = path.join(agentPath, 'HEARTBEAT.md');
+  if (fs.existsSync(heartbeatPath)) {
+    profile.heartbeat = fs.readFileSync(heartbeatPath, 'utf8');
+  }
+
+  return profile;
+}
+
+/**
+ * Discover all agent profiles from agents/ directory.
+ * Returns array of profile objects with id, name, codename, role, etc.
+ */
+export function discoverAgents() {
+  if (!fs.existsSync(agentsDir)) return [];
+
+  const entries = fs.readdirSync(agentsDir, { withFileTypes: true });
+  const agents = [];
+
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    if (SKIP_DIRS.includes(entry.name)) continue;
+
+    const profile = loadAgentProfile(entry.name);
+    if (profile) agents.push(profile);
+  }
+
+  return agents;
+}
+
+/**
+ * Get a bullet-list summary of all discovered agents (for {{agents}} variable).
+ */
+export function loadAgentDescriptions() {
+  const agents = discoverAgents();
+  if (agents.length === 0) return 'No agent profiles configured.';
+
+  return agents.map(a => {
+    const name = a.codename || a.name || a.id;
+    const role = a.role || 'general';
+    return `- **${name}**: ${role}`;
+  }).join('\n');
+}

package/lib/ai/agent.js

@@ -0,0 +1,96 @@
+import { createReactAgent } from '@langchain/langgraph/prebuilt';
+import { SystemMessage } from '@langchain/core/messages';
+import { createModel } from './model.js';
+import { createJobTool, getJobStatusTool, getSystemTechnicalSpecsTool, getSkillBuildingGuideTool } from './tools.js';
+import { SqliteSaver } from '@langchain/langgraph-checkpoint-sqlite';
+import { eventHandlerMd, thepopebotDb } from '../paths.js';
+import { render_md } from '../utils/render-md.js';
+import { loadAgentProfile } from '../agents.js';
+
+let _agent = null;
+
+/**
+ * Get or create the LangGraph agent singleton.
+ * Uses createReactAgent which handles the tool loop automatically.
+ * Prompt is a function so {{datetime}} resolves fresh each invocation.
+ */
+export async function getAgent() {
+  if (!_agent) {
+    const model = await createModel();
+    let mcpTools = [];
+    try {
+      const { loadMcpTools } = await import('../mcp/client.js');
+      mcpTools = await loadMcpTools();
+    } catch (err) {
+      console.error('[getAgent] Failed to load MCP tools:', err.message);
+    }
+    const tools = [createJobTool, getJobStatusTool, getSystemTechnicalSpecsTool, getSkillBuildingGuideTool, ...mcpTools];
+    const checkpointer = SqliteSaver.fromConnString(thepopebotDb);
+
+    _agent = createReactAgent({
+      llm: model,
+      tools,
+      checkpointSaver: checkpointer,
+      prompt: (state) => [new SystemMessage(render_md(eventHandlerMd)), ...state.messages],
+    });
+  }
+  return _agent;
+}
+
+/**
+ * Reset the agent singleton (e.g., when config changes).
+ */
+export function resetAgent() {
+  _agent = null;
+}
+
+// Per-profile agent instances
+const _agents = new Map();
+
+/**
+ * Get or create an agent for a specific agent profile.
+ * Uses the agent's SOUL.md as the system prompt instead of EVENT_HANDLER.md.
+ * Falls back to getAgent() if no profile found.
+ *
+ * @param {string} profileName - Directory name of the agent profile (e.g. 'recon-scout')
+ */
+export async function getAgentForProfile(profileName) {
+  if (_agents.has(profileName)) return _agents.get(profileName);
+
+  const profile = loadAgentProfile(profileName);
+  if (!profile || !profile.soul) return getAgent(); // fallback to default
+
+  const model = await createModel();
+  let mcpTools = [];
+  try {
+    const { loadMcpTools } = await import('../mcp/client.js');
+    mcpTools = await loadMcpTools();
+  } catch (err) {
+    console.error(`[getAgentForProfile:${profileName}] Failed to load MCP tools:`, err.message);
+  }
+  const tools = [createJobTool, getJobStatusTool, getSystemTechnicalSpecsTool, getSkillBuildingGuideTool, ...mcpTools];
+  const checkpointer = SqliteSaver.fromConnString(thepopebotDb);
+
+  // Build the system prompt from the agent's SOUL + optional SKILLS + TOOLS
+  const systemParts = [profile.soul];
+  if (profile.skills) systemParts.push('\n\n## Skills\n\n' + profile.skills);
+  if (profile.tools) systemParts.push('\n\n## Tools\n\n' + profile.tools);
+  const systemPrompt = systemParts.join('');
+
+  const agent = createReactAgent({
+    llm: model,
+    tools,
+    checkpointSaver: checkpointer,
+    prompt: (state) => [new SystemMessage(systemPrompt), ...state.messages],
+  });
+
+  _agents.set(profileName, agent);
+  return agent;
+}
+
+/**
+ * Reset a specific profile agent (e.g., when config changes).
+ */
+export function resetAgentForProfile(profileName) {
+  _agents.delete(profileName);
+}