@harbinger-ai/harbinger 0.1.0

package/lib/utils/render-md.js

@@ -0,0 +1,102 @@
+import fs from 'fs';
+import path from 'path';
+import { PROJECT_ROOT, piSkillsDir } from '../paths.js';
+import { loadAgentDescriptions } from '../agents.js';
+
+const INCLUDE_PATTERN = /\{\{([^}]+\.md)\}\}/g;
+const VARIABLE_PATTERN = /\{\{(datetime|skills|agents)\}\}/gi;
+
+// Scan skill directories under .pi/skills/ for SKILL.md files and extract
+// description from YAML frontmatter. Returns a bullet list of descriptions.
+function loadSkillDescriptions() {
+  try {
+    if (!fs.existsSync(piSkillsDir)) {
+      return 'No additional abilities configured.';
+    }
+
+    const entries = fs.readdirSync(piSkillsDir, { withFileTypes: true });
+    const descriptions = [];
+
+    for (const entry of entries) {
+      if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
+
+      const skillMdPath = path.join(piSkillsDir, entry.name, 'SKILL.md');
+      if (!fs.existsSync(skillMdPath)) continue;
+
+      const content = fs.readFileSync(skillMdPath, 'utf8');
+      const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+      if (!frontmatterMatch) continue;
+
+      const frontmatter = frontmatterMatch[1];
+      const descMatch = frontmatter.match(/^description:\s*(.+)$/m);
+      if (descMatch) {
+        descriptions.push(`- ${descMatch[1].trim()}`);
+      }
+    }
+
+    if (descriptions.length === 0) {
+      return 'No additional abilities configured.';
+    }
+
+    return descriptions.join('\n');
+  } catch {
+    return 'No additional abilities configured.';
+  }
+}
+
+/**
+ * Resolve built-in variables like {{datetime}} and {{skills}}.
+ * @param {string} content - Content with possible variable placeholders
+ * @returns {string} Content with variables resolved
+ */
+function resolveVariables(content) {
+  return content.replace(VARIABLE_PATTERN, (match, variable) => {
+    switch (variable.toLowerCase()) {
+      case 'datetime':
+        return new Date().toISOString();
+      case 'skills':
+        return loadSkillDescriptions();
+      case 'agents':
+        return loadAgentDescriptions();
+      default:
+        return match;
+    }
+  });
+}
+
+/**
+ * Render a markdown file, resolving {{filepath}} includes recursively
+ * and {{datetime}}, {{skills}} built-in variables.
+ * Referenced file paths resolve relative to the project root.
+ * @param {string} filePath - Absolute path to the markdown file
+ * @param {string[]} [chain=[]] - Already-resolved file paths (for circular detection)
+ * @returns {string} Rendered markdown content
+ */
+function render_md(filePath, chain = []) {
+  const resolved = path.resolve(filePath);
+
+  if (chain.includes(resolved)) {
+    const cycle = [...chain, resolved].map((p) => path.relative(PROJECT_ROOT, p)).join(' -> ');
+    console.log(`[render_md] Circular include detected: ${cycle}`);
+    return '';
+  }
+
+  if (!fs.existsSync(resolved)) {
+    return '';
+  }
+
+  const content = fs.readFileSync(resolved, 'utf8');
+  const currentChain = [...chain, resolved];
+
+  const withIncludes = content.replace(INCLUDE_PATTERN, (match, includePath) => {
+    const includeResolved = path.resolve(PROJECT_ROOT, includePath.trim());
+    if (!fs.existsSync(includeResolved)) {
+      return match;
+    }
+    return render_md(includeResolved, currentChain);
+  });
+
+  return resolveVariables(withIncludes);
+}
+
+export { render_md };

package/package.json

@@ -0,0 +1,103 @@
+{
+  "name": "@harbinger-ai/harbinger",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Create autonomous AI agents with a two-layer architecture: Next.js Event Handler + Docker Agent.",
+  "bin": {
+    "harbinger": "./bin/cli.js",
+    "thepopebot": "./bin/cli.js"
+  },
+  "main": "api/index.js",
+  "exports": {
+    "./api": "./api/index.js",
+    "./config": "./config/index.js",
+    "./instrumentation": "./config/instrumentation.js",
+    "./auth": "./lib/auth/index.js",
+    "./auth/actions": "./lib/auth/actions.js",
+    "./chat/api": "./lib/chat/api.js",
+    "./db": "./lib/db/index.js",
+    "./chat": "./lib/chat/components/index.js",
+    "./chat/actions": "./lib/chat/actions.js",
+    "./middleware": "./lib/auth/middleware.js",
+    "./mcp": "./lib/mcp/server.js",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "agents/",
+    "bin/",
+    "lib/",
+    "api/",
+    "config/",
+    "setup/",
+    "templates/",
+    "drizzle/"
+  ],
+  "scripts": {
+    "build": "esbuild lib/chat/components/*.jsx lib/chat/components/**/*.jsx --outdir=lib/chat/components --format=esm --jsx=automatic --outbase=lib/chat/components",
+    "prepublishOnly": "npm run build",
+    "local": "bash bin/local.sh",
+    "postinstall": "node -e \"import('./bin/postinstall.js').catch(()=>{})\"",
+    "db:generate": "drizzle-kit generate",
+    "db:studio": "drizzle-kit studio",
+    "test": "echo \"No tests yet\" && exit 0"
+  },
+  "keywords": [
+    "ai",
+    "agent",
+    "autonomous",
+    "telegram",
+    "bot",
+    "claude",
+    "nextjs"
+  ],
+  "author": "Stephen Pope",
+  "license": "MIT",
+  "dependencies": {
+    "@ai-sdk/react": "^2.0.0",
+    "@grammyjs/parse-mode": "^2.2.0",
+    "@langchain/anthropic": "^1.3.17",
+    "@langchain/core": "^1.1.24",
+    "@langchain/google-genai": "^2.1.18",
+    "@langchain/mcp-adapters": "^0.6.0",
+    "@langchain/langgraph": "^1.1.4",
+    "@langchain/langgraph-checkpoint-sqlite": "^1.0.1",
+    "@langchain/openai": "^1.2.7",
+    "@modelcontextprotocol/sdk": "^1.27.0",
+    "ai": "^5.0.0",
+    "bcrypt-ts": "^6.0.0",
+    "better-sqlite3": "^12.6.2",
+    "chalk": "^5.3.0",
+    "class-variance-authority": "^0.7.0",
+    "clsx": "^2.0.0",
+    "dotenv": "^16.3.1",
+    "framer-motion": "^11.0.0",
+    "drizzle-orm": "^0.44.0",
+    "grammy": "^1.39.3",
+    "@clack/prompts": "^0.10.0",
+    "lucide-react": "^0.400.0",
+    "node-cron": "^3.0.3",
+    "open": "^10.0.0",
+    "streamdown": "^2.2.0",
+    "tailwind-merge": "^3.0.0",
+    "uuid": "^9.0.0",
+    "zod": "^4.3.6"
+  },
+  "peerDependencies": {
+    "next": ">=15.5.12",
+    "next-auth": "^5.0.0-beta.30",
+    "react": ">=19.0.0",
+    "react-dom": ">=19.0.0"
+  },
+  "peerDependenciesMeta": {
+    "next-auth": {
+      "optional": false
+    }
+  },
+  "devDependencies": {
+    "drizzle-kit": "^0.31.9",
+    "esbuild": "^0.27.3"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/setup/lib/auth.mjs

@@ -0,0 +1,81 @@
+import { writeFileSync, readFileSync, existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+
+const ROOT_DIR = process.cwd();
+
+/**
+ * Validate Anthropic API key by making a minimal test call
+ */
+export async function validateAnthropicKey(key) {
+  try {
+    const response = await fetch('https://api.anthropic.com/v1/messages', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'x-api-key': key,
+        'anthropic-version': '2023-06-01',
+      },
+      body: JSON.stringify({
+        model: 'claude-3-haiku-20240307',
+        max_tokens: 1,
+        messages: [{ role: 'user', content: 'Hi' }],
+      }),
+    });
+
+    if (response.status === 401) {
+      return { valid: false, error: 'Invalid API key' };
+    }
+    if (response.status === 400) {
+      // Bad request but key is valid (e.g., rate limit, model error)
+      return { valid: true };
+    }
+    if (response.ok) {
+      return { valid: true };
+    }
+    return { valid: false, error: `HTTP ${response.status}` };
+  } catch (error) {
+    return { valid: false, error: error.message };
+  }
+}
+
+/**
+ * Generate .pi/agent/models.json for providers not built into PI.
+ * PI resolves the apiKey field as an env var name at runtime ($ENV_VAR).
+ */
+export function writeModelsJson(providerName, { baseUrl, apiKey, api, models }) {
+  const config = {
+    providers: {
+      [providerName]: {
+        baseUrl,
+        apiKey,
+        api: api || 'openai-completions',
+        models: models.map((m) => ({ id: m })),
+      },
+    },
+  };
+  const dir = join(ROOT_DIR, '.pi', 'agent');
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, 'models.json'), JSON.stringify(config, null, 2));
+}
+
+/**
+ * Update a single variable in an existing .env file
+ */
+export function updateEnvVariable(key, value) {
+  const envPath = join(ROOT_DIR, '.env');
+  if (!existsSync(envPath)) {
+    throw new Error('.env file not found. Run npm run setup first.');
+  }
+
+  let content = readFileSync(envPath, 'utf-8');
+  const regex = new RegExp(`^${key}=.*$`, 'm');
+
+  if (regex.test(content)) {
+    content = content.replace(regex, `${key}=${value}`);
+  } else {
+    content = content.trimEnd() + `\n${key}=${value}\n`;
+  }
+
+  writeFileSync(envPath, content);
+  return envPath;
+}

package/setup/lib/env.mjs

@@ -0,0 +1,21 @@
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+
+/**
+ * Parse .env file and return object, or null if no .env exists
+ */
+export function loadEnvFile(dir = process.cwd()) {
+  const envPath = join(dir, '.env');
+  if (!existsSync(envPath)) {
+    return null;
+  }
+  const content = readFileSync(envPath, 'utf-8');
+  const env = {};
+  for (const line of content.split('\n')) {
+    const match = line.match(/^([^#=]+)=(.*)$/);
+    if (match) {
+      env[match[1].trim()] = match[2].trim();
+    }
+  }
+  return env;
+}

package/setup/lib/fs-utils.mjs

@@ -0,0 +1,20 @@
+import fs from 'fs';
+import path from 'path';
+
+/**
+ * Create a directory symlink (Unix) or junction/copy fallback (Windows).
+ */
+export function createDirLink(target, linkPath) {
+  if (process.platform !== 'win32') {
+    fs.symlinkSync(target, linkPath);
+    return;
+  }
+  // Junctions require absolute targets but don't require admin privileges
+  const absoluteTarget = path.resolve(path.dirname(linkPath), target);
+  try {
+    fs.symlinkSync(absoluteTarget, linkPath, 'junction');
+  } catch {
+    fs.cpSync(absoluteTarget, linkPath, { recursive: true });
+    console.log('    (copied — symlinks unavailable on this system)');
+  }
+}

package/setup/lib/github.mjs

@@ -0,0 +1,149 @@
+import { execSync, exec } from 'child_process';
+import { promisify } from 'util';
+import { randomBytes } from 'crypto';
+import { ghEnv } from './prerequisites.mjs';
+
+const execAsync = promisify(exec);
+
+/**
+ * Validate GitHub PAT by making a test API call
+ */
+export async function validatePAT(token) {
+  try {
+    const response = await fetch('https://api.github.com/user', {
+      headers: {
+        Authorization: `token ${token}`,
+        Accept: 'application/vnd.github.v3+json',
+      },
+    });
+    if (!response.ok) return { valid: false, error: 'Invalid token' };
+    const user = await response.json();
+    return { valid: true, user: user.login };
+  } catch (error) {
+    return { valid: false, error: error.message };
+  }
+}
+
+/**
+ * Check PAT scopes/permissions
+ * Works with both classic tokens (x-oauth-scopes header) and fine-grained tokens
+ */
+export async function checkPATScopes(token) {
+  try {
+    const response = await fetch('https://api.github.com/user', {
+      headers: {
+        Authorization: `token ${token}`,
+        Accept: 'application/vnd.github.v3+json',
+      },
+    });
+    const scopes = response.headers.get('x-oauth-scopes') || '';
+    const scopeList = scopes.split(',').map((s) => s.trim()).filter(Boolean);
+
+    // Classic tokens have x-oauth-scopes header
+    if (scopeList.length > 0) {
+      return {
+        hasRepo: scopeList.includes('repo'),
+        hasWorkflow: scopeList.includes('workflow'),
+        scopes: scopeList,
+        isFineGrained: false,
+      };
+    }
+
+    // Fine-grained tokens don't have x-oauth-scopes header
+    // We can't check permissions directly, so we assume valid if token works
+    return {
+      hasRepo: true,
+      hasWorkflow: true,
+      scopes: [],
+      isFineGrained: true,
+    };
+  } catch {
+    return { hasRepo: false, hasWorkflow: false, scopes: [], isFineGrained: false };
+  }
+}
+
+/**
+ * Set a GitHub repository secret using gh CLI
+ */
+export async function setSecret(owner, repo, name, value) {
+  try {
+    execSync(
+      `gh secret set ${name} --repo ${owner}/${repo}`,
+      { input: value, encoding: 'utf-8', env: ghEnv(), stdio: ['pipe', 'pipe', 'pipe'] }
+    );
+    return { success: true };
+  } catch (error) {
+    return { success: false, error: error.message };
+  }
+}
+
+/**
+ * Set multiple GitHub secrets
+ */
+export async function setSecrets(owner, repo, secrets) {
+  const results = {};
+  for (const [name, value] of Object.entries(secrets)) {
+    results[name] = await setSecret(owner, repo, name, value);
+  }
+  return results;
+}
+
+/**
+ * List existing secrets
+ */
+export async function listSecrets(owner, repo) {
+  try {
+    const { stdout } = await execAsync(`gh secret list --repo ${owner}/${repo}`, {
+      encoding: 'utf-8',
+      env: ghEnv(),
+    });
+    const secrets = stdout
+      .trim()
+      .split('\n')
+      .filter(Boolean)
+      .map((line) => line.split('\t')[0]);
+    return secrets;
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Set a GitHub repository variable using gh CLI
+ */
+export async function setVariable(owner, repo, name, value) {
+  try {
+    execSync(
+      `gh variable set ${name} --repo ${owner}/${repo}`,
+      { input: value, encoding: 'utf-8', env: ghEnv(), stdio: ['pipe', 'pipe', 'pipe'] }
+    );
+    return { success: true };
+  } catch (error) {
+    return { success: false, error: error.message };
+  }
+}
+
+/**
+ * Set multiple GitHub repository variables
+ */
+export async function setVariables(owner, repo, variables) {
+  const results = {};
+  for (const [name, value] of Object.entries(variables)) {
+    results[name] = await setVariable(owner, repo, name, value);
+  }
+  return results;
+}
+
+/**
+ * Generate a random webhook secret
+ */
+export function generateWebhookSecret() {
+  return randomBytes(32).toString('hex');
+}
+
+/**
+ * Get the GitHub PAT creation URL with pre-selected scopes
+ */
+export function getPATCreationURL() {
+  return 'https://github.com/settings/personal-access-tokens/new';
+}

package/setup/lib/prerequisites.mjs

@@ -0,0 +1,155 @@
+import { execSync, exec } from 'child_process';
+import { promisify } from 'util';
+
+const execAsync = promisify(exec);
+
+/**
+ * Return process.env without GITHUB_TOKEN and GH_TOKEN.
+ * The gh CLI auto-uses these env vars, which can shadow interactive login
+ * and cause secret/variable operations to fail with the wrong identity.
+ */
+export function ghEnv() {
+  const env = { ...process.env };
+  delete env.GITHUB_TOKEN;
+  delete env.GH_TOKEN;
+  return env;
+}
+
+/**
+ * Check if a command exists
+ */
+function commandExists(cmd) {
+  const checkCmd = process.platform === 'win32' ? 'where' : 'which';
+  try {
+    execSync(`${checkCmd} ${cmd}`, { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Get Node.js version
+ */
+function getNodeVersion() {
+  try {
+    const version = execSync('node --version', { encoding: 'utf-8' }).trim();
+    return version.replace('v', '');
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Check if gh CLI is authenticated
+ */
+async function isGhAuthenticated() {
+  try {
+    await execAsync('gh auth status', { env: ghEnv() });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Get git remote info (owner/repo)
+ */
+function getGitRemoteInfo() {
+  try {
+    const remote = execSync('git remote get-url origin', { encoding: 'utf-8' }).trim();
+    // Handle both HTTPS and SSH formats
+    // https://github.com/owner/repo.git
+    // git@github.com:owner/repo.git
+    const httpsMatch = remote.match(/github\.com\/([^/]+)\/(.+?)(?:\.git)?$/);
+    const sshMatch = remote.match(/github\.com:([^/]+)\/(.+?)(?:\.git)?$/);
+    const match = httpsMatch || sshMatch;
+    if (match) {
+      return { owner: match[1], repo: match[2] };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Get package manager (pnpm preferred, npm fallback)
+ */
+function getPackageManager() {
+  if (commandExists('pnpm')) return 'pnpm';
+  if (commandExists('npm')) return 'npm';
+  return null;
+}
+
+/**
+ * Check all prerequisites and return status
+ */
+export async function checkPrerequisites() {
+  const results = {
+    node: { installed: false, version: null, ok: false },
+    packageManager: { installed: false, name: null },
+    gh: { installed: false, authenticated: false },
+    ngrok: { installed: false },
+    git: { installed: false, remoteInfo: null },
+  };
+
+  // Check Node.js
+  const nodeVersion = getNodeVersion();
+  if (nodeVersion) {
+    results.node.installed = true;
+    results.node.version = nodeVersion;
+    const [major] = nodeVersion.split('.').map(Number);
+    results.node.ok = major >= 18;
+  }
+
+  // Check package manager
+  const pm = getPackageManager();
+  if (pm) {
+    results.packageManager.installed = true;
+    results.packageManager.name = pm;
+  }
+
+  // Check gh CLI
+  results.gh.installed = commandExists('gh');
+  if (results.gh.installed) {
+    results.gh.authenticated = await isGhAuthenticated();
+  }
+
+  // Check ngrok
+  results.ngrok.installed = commandExists('ngrok');
+
+  // Check git
+  results.git.installed = commandExists('git');
+  if (results.git.installed) {
+    // Initialize git repo if needed (must happen before remote check)
+    try {
+      execSync('git rev-parse --git-dir', { stdio: 'ignore' });
+      results.git.initialized = true;
+    } catch {
+      results.git.initialized = false;
+    }
+    results.git.remoteInfo = getGitRemoteInfo();
+  }
+
+  return results;
+}
+
+/**
+ * Install a global npm package
+ */
+export async function installGlobalPackage(packageName) {
+  const pm = getPackageManager();
+  const cmd = pm === 'pnpm' ? `pnpm add -g ${packageName}` : `npm install -g ${packageName}`;
+  await execAsync(cmd);
+}
+
+/**
+ * Run gh auth login
+ */
+export async function runGhAuth() {
+  // This needs to be interactive, so we use execSync
+  execSync('gh auth login', { stdio: 'inherit', env: ghEnv() });
+}
+
+export { commandExists, getGitRemoteInfo, getPackageManager };