@grantx/fleet-core 0.1.0

package/src/conductor-runner.js

@@ -0,0 +1,182 @@
+// conductor-runner.js — Dedicated conductor channel.
+// Separate from AgentPool to avoid contention with worker agents.
+
+import { spawn } from 'node:child_process';
+import { existsSync, readFileSync, writeFileSync, unlinkSync, mkdirSync } from 'node:fs';
+import { randomUUID } from 'node:crypto';
+import path from 'node:path';
+import { log } from './logger.js';
+import { lockDir, ensureLockDir, buildAgentEnv, agentHome as resolveAgentHome } from './platform.js';
+import { getConductor } from './config.js';
+
+const LOCK_FILENAME = 'fleet-conductor.lock';
+
+export class ConductorRunner {
+  constructor(config) {
+    this.config = config;
+    this.projectRoot = config._projectRoot || config.projectRoot || process.cwd();
+    this.teamId = config.teamId;
+    this.running = false;
+    this._process = null;
+
+    const conductor = getConductor(config);
+    this.conductorName = conductor?.name || 'conductor';
+
+    // Load or create session
+    const sessFile = path.join(this.projectRoot, '.fleet', 'sessions.json');
+    try {
+      const sessions = JSON.parse(readFileSync(sessFile, 'utf8'));
+      const entry = sessions[this.conductorName];
+      if (typeof entry === 'string') {
+        this.sessionId = entry;
+        this.initialized = false;
+      } else if (entry) {
+        this.sessionId = entry.id;
+        this.initialized = entry.initialized || false;
+      } else {
+        this.sessionId = randomUUID();
+        this.initialized = false;
+      }
+    } catch {
+      this.sessionId = randomUUID();
+      this.initialized = false;
+    }
+
+    ensureLockDir();
+  }
+
+  async invoke(prompt) {
+    if (this.running) {
+      return { ok: false, message: 'Conductor is already running' };
+    }
+
+    const lockFile = path.join(lockDir, LOCK_FILENAME);
+    const homeDir = resolveAgentHome(this.projectRoot, this.conductorName);
+    const workDir = this.projectRoot;
+
+    return this._spawn(prompt, lockFile, homeDir, workDir);
+  }
+
+  async _spawn(prompt, lockFile, homeDir, workDir, retryCount = 0) {
+    return new Promise((resolve) => {
+      this.running = true;
+
+      try { writeFileSync(lockFile, String(process.pid)); } catch { /* ignore */ }
+
+      const env = buildAgentEnv(this.conductorName, homeDir, this.teamId);
+      let stdout = '';
+      let stderr = '';
+
+      const sessionFlag = this.initialized ? '--resume' : '--session-id';
+      const child = spawn('claude', [
+        '-p', prompt,
+        '--dangerously-skip-permissions',
+        sessionFlag, this.sessionId,
+      ], {
+        cwd: workDir,
+        env,
+        stdio: ['ignore', 'pipe', 'pipe'],
+      });
+
+      this._process = child;
+
+      // 10 minute timeout for conductor
+      const timeoutTimer = setTimeout(() => {
+        if (this.running) {
+          log.warn('conductor-runner', `Conductor timed out after 600s`);
+          try { child.kill('SIGTERM'); } catch { /* ignore */ }
+        }
+      }, 600000);
+
+      log.info('conductor-runner', `Spawned conductor (PID ${child.pid}, ${sessionFlag} ${this.sessionId.slice(0, 8)}...)`);
+
+      child.stdout.on('data', (data) => { stdout += data.toString(); });
+      child.stderr.on('data', (data) => { stderr += data.toString(); });
+
+      child.on('close', (code) => {
+        clearTimeout(timeoutTimer);
+        this.running = false;
+        this._process = null;
+        try { unlinkSync(lockFile); } catch { /* ignore */ }
+
+        const output = stdout.trim();
+        const errText = stderr.trim();
+
+        // Self-healing
+        if (code === 1 && retryCount < 2) {
+          if (errText.includes('already in use') && !this.initialized) {
+            log.info('conductor-runner', 'Session exists, retrying with --resume');
+            this.initialized = true;
+            this._saveSession();
+            this._spawn(prompt, lockFile, homeDir, workDir, retryCount + 1).then(resolve);
+            return;
+          }
+          if (errText.includes('No conversation found') && this.initialized) {
+            this.sessionId = randomUUID();
+            this.initialized = false;
+            this._saveSession();
+            log.info('conductor-runner', `Fresh session ${this.sessionId.slice(0, 8)}`);
+            this._spawn(prompt, lockFile, homeDir, workDir, retryCount + 1).then(resolve);
+            return;
+          }
+        }
+
+        if (code === 0 || (code === null && output.length > 0)) {
+          if (!this.initialized) {
+            this.initialized = true;
+            this._saveSession();
+          }
+          log.info('conductor-runner', `Conductor completed (${output.length} chars)`);
+          resolve({ ok: true, output });
+        } else {
+          const errMsg = errText.slice(0, 500) || 'No output';
+          log.warn('conductor-runner', `Conductor exited with code ${code}: ${errMsg.slice(0, 200)}`);
+          resolve({ ok: false, message: `Conductor exited with code ${code}: ${errMsg}` });
+        }
+      });
+
+      child.on('error', (err) => {
+        clearTimeout(timeoutTimer);
+        this.running = false;
+        this._process = null;
+        try { unlinkSync(lockFile); } catch { /* ignore */ }
+        resolve({ ok: false, message: `Failed to spawn conductor: ${err.message}` });
+      });
+    });
+  }
+
+  _saveSession() {
+    const sessFile = path.join(this.projectRoot, '.fleet', 'sessions.json');
+    try {
+      let sessions = {};
+      try { sessions = JSON.parse(readFileSync(sessFile, 'utf8')); } catch { /* new file */ }
+      sessions[this.conductorName] = { id: this.sessionId, initialized: this.initialized };
+      mkdirSync(path.dirname(sessFile), { recursive: true });
+      writeFileSync(sessFile, JSON.stringify(sessions, null, 2));
+    } catch (err) {
+      log.error('conductor-runner', `Failed to save session: ${err.message}`);
+    }
+  }
+
+  kill() {
+    if (this._process) {
+      try { this._process.kill('SIGTERM'); } catch { /* ignore */ }
+    }
+  }
+}
+
+/**
+ * Parse the ---DISPATCH--- block from conductor output.
+ * Returns { dispatches, surface, reviews, kills } or null if no block found.
+ */
+export function parseDispatchBlock(output) {
+  const match = output.match(/---DISPATCH---([\s\S]*?)---END---/);
+  if (!match) return null;
+
+  try {
+    return JSON.parse(match[1].trim());
+  } catch {
+    log.warn('conductor-runner', 'Failed to parse DISPATCH block as JSON');
+    return null;
+  }
+}

package/src/config.js

@@ -0,0 +1,103 @@
+// config.js — Load and validate fleet.config.json
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+/**
+ * Load fleet.config.json from the given path, or search upward from cwd.
+ * Returns a frozen config object.
+ */
+export function loadConfig(configPath) {
+  const resolved = configPath
+    ? path.resolve(configPath)
+    : findConfigFile(process.cwd());
+
+  if (!resolved) {
+    throw new Error(
+      'fleet.config.json not found. Run `fleet init` to create one.'
+    );
+  }
+
+  let raw;
+  try {
+    raw = JSON.parse(fs.readFileSync(resolved, 'utf8'));
+  } catch (err) {
+    throw new Error(`Failed to parse ${resolved}: ${err.message}`);
+  }
+
+  validate(raw, resolved);
+
+  // Attach resolved paths
+  raw._configPath = resolved;
+  raw._projectRoot = raw.projectRoot || path.dirname(resolved);
+
+  return Object.freeze(raw);
+}
+
+/**
+ * Search upward from dir for fleet.config.json.
+ */
+function findConfigFile(dir) {
+  let current = path.resolve(dir);
+  const root = path.parse(current).root;
+
+  while (current !== root) {
+    const candidate = path.join(current, 'fleet.config.json');
+    if (fs.existsSync(candidate)) return candidate;
+    current = path.dirname(current);
+  }
+  return null;
+}
+
+/**
+ * Validate config schema. Throws on invalid.
+ */
+function validate(config, filePath) {
+  if (config.version !== 1) {
+    throw new Error(`${filePath}: unsupported version ${config.version} (expected 1)`);
+  }
+  if (!config.teamId || typeof config.teamId !== 'string') {
+    throw new Error(`${filePath}: teamId is required (string)`);
+  }
+  if (!config.supabase?.url || !config.supabase?.key) {
+    throw new Error(`${filePath}: supabase.url and supabase.key are required`);
+  }
+  if (!Array.isArray(config.agents) || config.agents.length === 0) {
+    throw new Error(`${filePath}: agents array is required and must be non-empty`);
+  }
+
+  const conductors = config.agents.filter(a => a.isConductor);
+  if (conductors.length !== 1) {
+    throw new Error(`${filePath}: exactly one agent must have isConductor: true (found ${conductors.length})`);
+  }
+
+  for (const agent of config.agents) {
+    if (!agent.name || typeof agent.name !== 'string') {
+      throw new Error(`${filePath}: each agent must have a name (string)`);
+    }
+    if (!agent.role || typeof agent.role !== 'string') {
+      throw new Error(`${filePath}: agent "${agent.name}" must have a role (string)`);
+    }
+  }
+}
+
+/**
+ * Get the full agent roster from config.
+ */
+export function getAgentRoster(config) {
+  return config.agents;
+}
+
+/**
+ * Get the conductor agent entry.
+ */
+export function getConductor(config) {
+  return config.agents.find(a => a.isConductor);
+}
+
+/**
+ * Get worker (non-conductor) agents.
+ */
+export function getWorkerAgents(config) {
+  return config.agents.filter(a => !a.isConductor);
+}

package/src/dispatch-prompts.js

@@ -0,0 +1,141 @@
+// dispatch-prompts.js — Templatized prompt builders.
+// No grantx-kb references. Agent names from config.
+
+import { getWorkerAgents, getConductor } from './config.js';
+
+/**
+ * Build the task dispatch prompt sent to a worker agent.
+ */
+export function buildTaskDispatchPrompt(agent, task, config) {
+  const agentConfig = config.agents.find(a => a.name === agent);
+  const role = agentConfig?.role || 'general purpose agent';
+
+  return `You are "${agent}", a fleet agent specializing in: ${role}.
+
+## Your Task
+
+**Task ID**: ${task.id}
+**Title**: ${task.title}
+**Priority**: ${task.priority || 3} (1=highest, 5=lowest)
+${task.description ? `**Description**: ${task.description}` : ''}
+${task.sprint_id ? `**Sprint**: ${task.sprint_id}` : ''}
+
+## Instructions
+
+1. **Understand** the task fully before starting work.
+2. **Search** the codebase for relevant files and context.
+3. **Implement** the required changes, following existing patterns and conventions.
+4. **Test** your changes if a test suite exists.
+5. **Document** what you did and any decisions you made.
+
+## Output Format
+
+When you're done, output a clear summary of:
+- What you did (specific files changed, functions added/modified)
+- Why you made the choices you did
+- Any issues or blockers encountered
+- Suggestions for follow-up work (if any)
+
+Keep your summary concise but thorough — it will be stored as the task result.`;
+}
+
+/**
+ * Build the conductor orchestration prompt for event-driven decisions.
+ */
+export function buildConductorEventPrompt(events, state, config) {
+  const workers = getWorkerAgents(config);
+  const workerList = workers.map(a => `- ${a.name}: ${a.role}`).join('\n');
+
+  let prompt = `You are the fleet conductor. You orchestrate a team of AI agents.
+
+## Available Agents
+${workerList}
+
+## Current Fleet State
+
+**Pending tasks** (${(state.pendingTasks || []).length}):
+`;
+
+  for (const t of (state.pendingTasks || []).slice(0, 10)) {
+    const deps = t.depends_on?.length ? ` [deps: ${t._deps_satisfied || 0}/${t.depends_on.length} done]` : '';
+    const assignee = t.to_agent ? ` -> ${t.to_agent}` : '';
+    prompt += `  P${t.priority || 3}${assignee}: "${t.title}"${deps} (${t.id.slice(0, 8)})\n`;
+  }
+
+  prompt += `\n**Active tasks** (${(state.activeTasks || []).length}):\n`;
+  for (const t of (state.activeTasks || []).slice(0, 10)) {
+    prompt += `  ${t.to_agent}: "${t.title}" (${t.status})\n`;
+  }
+
+  if (state.blockedTasks?.length > 0) {
+    prompt += `\n**Blocked tasks** (${state.blockedTasks.length}):\n`;
+    for (const t of state.blockedTasks.slice(0, 5)) {
+      prompt += `  ${t.to_agent}: "${t.title}" — ${t.blocked_reason || 'no reason'}\n`;
+    }
+  }
+
+  if (state.sprintProgress) {
+    prompt += `\n**Sprint**: ${state.sprint?.title || 'active'} — ${state.sprintProgress}\n`;
+  }
+
+  prompt += `\n## Events Since Last Cycle\n`;
+  for (const e of events) {
+    if (e.type === 'task_completed') {
+      prompt += `- COMPLETED: ${e.agent} finished "${e.title}"\n`;
+    } else if (e.type === 'task_failed') {
+      prompt += `- FAILED: ${e.agent} failed on "${e.title}" (attempt ${e.failure_count}): ${e.failure_reason || 'unknown'}\n`;
+    } else if (e.type === 'task_flagged') {
+      prompt += `- FLAGGED: ${e.agent} flagged "${e.title}" as ${e.flag_type}: ${e.flag_reason || ''}\n`;
+    } else if (e.type === 'task_unblocked') {
+      prompt += `- UNBLOCKED: "${e.title}" — all dependencies completed\n`;
+    } else if (e.type === 'dispatch_tick') {
+      prompt += `- DISPATCH_TICK: check for pending work to assign\n`;
+    }
+  }
+
+  prompt += `
+## Your Decision
+
+Analyze the events and fleet state. Output your decisions in this exact format:
+
+\`\`\`
+---DISPATCH---
+{
+  "dispatches": [
+    { "agent": "<name>", "task_id": "<uuid>", "reason": "<why this agent>" }
+  ],
+  "surface": [
+    { "channel": "fleet-decisions", "message": "<status update>" }
+  ],
+  "reviews": [],
+  "kills": []
+}
+---END---
+\`\`\`
+
+Rules:
+- Only dispatch idle agents (not currently running).
+- Respect task dependencies — do not dispatch tasks with unsatisfied deps.
+- If no action needed, output an empty dispatches array.
+- Kill agents only if they appear stuck (running >30 min on a simple task).
+`;
+
+  return prompt;
+}
+
+/**
+ * Build a review prompt for code review tasks.
+ */
+export function buildReviewPrompt(reviewer, subject, taskId) {
+  return `You are "${reviewer}", assigned to review: ${subject}.
+
+${taskId ? `Task ID: ${taskId}` : ''}
+
+Review the recent changes and provide:
+1. Code quality assessment
+2. Potential issues or bugs
+3. Suggestions for improvement
+4. Approval or request for changes
+
+Be concise and actionable.`;
+}

package/src/fleet-utils.js

@@ -0,0 +1,189 @@
+// fleet-utils.js — Shared utilities for dispatch execution and fleet state.
+// Team-scoped version: all queries include team_id.
+
+import { log } from './logger.js';
+import { buildTaskDispatchPrompt, buildReviewPrompt } from './dispatch-prompts.js';
+
+/**
+ * Fetch current fleet state from Supabase (team-scoped).
+ */
+export async function fetchFleetState(supabase) {
+  try {
+    const [pendingTasks, activeTasks, blockedTasks, heartbeats, sprint, recentLessons, pendingPitches] = await Promise.all([
+      supabase.get('task_queue?status=eq.pending&order=priority.asc,created_at.desc&limit=30'),
+      supabase.get('task_queue?status=in.(claimed,in_progress)&order=created_at.desc&limit=20'),
+      supabase.get('task_queue?status=eq.blocked&order=flagged_at.desc&limit=10'),
+      supabase.get('heartbeats?order=created_at.desc&limit=50'),
+      supabase.get('sprints?status=eq.active&limit=1'),
+      supabase.get('knowledge?category=in.(lesson,gotcha)&superseded_by=is.null&order=hits.desc,created_at.desc&limit=5&select=title,category,confidence'),
+      supabase.get('pitches?status=eq.pending&select=id,agent_id,title&order=created_at.desc&limit=10'),
+    ]);
+
+    // Deduplicate heartbeats: latest per agent
+    const hbMap = new Map();
+    for (const hb of heartbeats) {
+      if (!hbMap.has(hb.agent_id)) hbMap.set(hb.agent_id, hb);
+    }
+
+    // Sprint progress
+    let sprintProgress = null;
+    const activeSprint = sprint[0] || null;
+    if (activeSprint) {
+      const sprintTasks = await supabase.get(
+        `task_queue?sprint_id=eq.${activeSprint.id}&select=status`
+      );
+      const counts = { total: sprintTasks.length, completed: 0, blocked: 0, pending: 0, active: 0 };
+      for (const t of sprintTasks) {
+        if (t.status === 'completed') counts.completed++;
+        else if (t.status === 'blocked') counts.blocked++;
+        else if (t.status === 'pending') counts.pending++;
+        else counts.active++;
+      }
+      sprintProgress = `${counts.completed}/${counts.total} complete, ${counts.active} active, ${counts.blocked} blocked, ${counts.pending} pending`;
+    }
+
+    return {
+      pendingTasks,
+      activeTasks,
+      blockedTasks,
+      recentHeartbeats: Array.from(hbMap.values()),
+      sprint: activeSprint,
+      sprintProgress,
+      recentLessons: recentLessons || [],
+      pendingPitches: pendingPitches || [],
+    };
+  } catch (err) {
+    log.error('fleet-utils', `Failed to fetch fleet state: ${err.message}`);
+    return {};
+  }
+}
+
+/**
+ * Execute structured decisions from conductor or smart-dispatcher.
+ */
+export async function executeDecisions(decisions, agentPool, supabase, config) {
+  // 1. Kills first (free capacity)
+  if (decisions.kills?.length > 0) {
+    for (const kill of decisions.kills) {
+      if (kill.agent) {
+        log.info('fleet-utils', `Kill ordered: ${kill.agent} — ${kill.reason || 'no reason'}`);
+        agentPool.killAgent(kill.agent);
+      }
+    }
+  }
+
+  // 2. Dispatches (fire all — agent pool handles concurrency)
+  if (decisions.dispatches?.length > 0) {
+    log.info('fleet-utils', `Dispatching ${decisions.dispatches.length} agents`);
+    for (const dispatch of decisions.dispatches) {
+      dispatchAgent(dispatch, agentPool, supabase, config);
+    }
+  }
+
+  // 3. Reviews
+  for (const review of (decisions.reviews || [])) {
+    await dispatchReview(review, agentPool);
+  }
+}
+
+/**
+ * Dispatch a single agent to a task.
+ */
+export async function dispatchAgent(dispatch, agentPool, supabase, config) {
+  const { agent, task_id, reason } = dispatch;
+  if (!agent || !task_id) {
+    log.warn('fleet-utils', 'Invalid dispatch: missing agent or task_id');
+    return;
+  }
+
+  try {
+    const tasks = await supabase.get(`task_queue?id=eq.${task_id}`);
+    const task = tasks[0];
+    if (!task) {
+      log.warn('fleet-utils', `Dispatch: task ${task_id} not found`);
+      return;
+    }
+
+    if (['completed', 'in_progress', 'claimed', 'failed'].includes(task.status)) {
+      log.info('fleet-utils', `Dispatch: task ${task_id} already ${task.status}, skipping`);
+      return;
+    }
+
+    // Circuit breaker
+    if ((task.failure_count || 0) >= 3) {
+      log.warn('fleet-utils', `Dispatch: task ${task_id} has ${task.failure_count} failures, halted`);
+      return;
+    }
+
+    log.info('fleet-utils', `Dispatching ${agent} to "${task.title}" (${task_id}): ${reason}`);
+    const prompt = buildTaskDispatchPrompt(agent, task, config);
+    const result = await agentPool.invoke(agent, prompt, { dispatch: true });
+
+    if (!result.ok) {
+      log.warn('fleet-utils', `Dispatch failed for ${agent}: ${result.message}`);
+      if (!result.busy) {
+        await recordTaskFailure(supabase, task_id, agent, result.message);
+      }
+      return;
+    }
+
+    log.info('fleet-utils', `${agent} completed dispatch (${result.output?.length || 0} chars)`);
+
+    // Store result
+    try {
+      await supabase.patch(`task_queue?id=eq.${task_id}`, {
+        status: 'completed',
+        result: result.output?.slice(0, 50000) || '(no output)',
+        completed_at: new Date().toISOString(),
+      });
+    } catch (err) {
+      log.warn('fleet-utils', `Failed to store dispatch result: ${err.message}`);
+    }
+  } catch (err) {
+    log.error('fleet-utils', `Dispatch error for ${agent}: ${err.message}`);
+    await recordTaskFailure(supabase, task_id, agent, err.message);
+  }
+}
+
+/**
+ * Record a task failure. Marks as 'failed' after 3 retries (circuit breaker).
+ */
+export async function recordTaskFailure(supabase, taskId, agent, reason) {
+  try {
+    const tasks = await supabase.get(`task_queue?id=eq.${taskId}&select=failure_count`);
+    const current = tasks[0]?.failure_count || 0;
+    const newCount = current + 1;
+    const maxRetries = 3;
+    const newStatus = newCount >= maxRetries ? 'failed' : 'pending';
+
+    await supabase.patch(`task_queue?id=eq.${taskId}`, {
+      status: newStatus,
+      failure_count: newCount,
+      last_failure_at: new Date().toISOString(),
+      last_failure_reason: reason?.slice(0, 500) || 'Unknown failure',
+    });
+
+    log.info('fleet-utils', `Recorded failure for task ${taskId} (attempt ${newCount}/${maxRetries}, status -> ${newStatus})`);
+  } catch (err) {
+    log.error('fleet-utils', `Failed to record task failure: ${err.message}`);
+  }
+}
+
+/**
+ * Dispatch a review to an agent.
+ */
+async function dispatchReview(review, agentPool) {
+  const { reviewer, subject, task_id } = review;
+  if (!reviewer || !subject) return;
+
+  log.info('fleet-utils', `Routing review to ${reviewer}: ${subject}`);
+  try {
+    const prompt = buildReviewPrompt(reviewer, subject, task_id);
+    const result = await agentPool.invoke(reviewer, prompt, { dispatch: true });
+    if (!result.ok) {
+      log.warn('fleet-utils', `Review dispatch failed for ${reviewer}: ${result.message}`);
+    }
+  } catch (err) {
+    log.error('fleet-utils', `Review dispatch error: ${err.message}`);
+  }
+}

package/src/index.js

@@ -0,0 +1,12 @@
+// @grantx/fleet-core — shared engine for the fleet plugin
+// Cross-platform, config-driven, no hardcoded Grantx references.
+
+export { loadConfig, getAgentRoster, getConductor, getWorkerAgents } from './config.js';
+export { AgentPool } from './agent-runner.js';
+export { ConductorRunner, parseDispatchBlock } from './conductor-runner.js';
+export { SmartDispatcher } from './smart-dispatcher.js';
+export { ConductorLoop } from './conductor-loop.js';
+export { SupabaseClient } from './supabase-client.js';
+export { fetchFleetState, executeDecisions, dispatchAgent, recordTaskFailure } from './fleet-utils.js';
+export { log } from './logger.js';
+export * from './platform.js';

package/src/logger.js

@@ -0,0 +1,49 @@
+// logger.js — Structured logging for fleet plugin.
+// Writes to .fleet/logs/fleet.log (configurable) + stdout fallback.
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+let logStream = null;
+let logDir = null;
+
+function initLogStream() {
+  if (logStream) return;
+
+  logDir = process.env.FLEET_LOG_DIR || null;
+  if (!logDir) {
+    // Try .fleet/logs/ relative to cwd
+    const candidate = path.join(process.cwd(), '.fleet', 'logs');
+    if (fs.existsSync(path.join(process.cwd(), '.fleet'))) {
+      logDir = candidate;
+    }
+  }
+
+  if (logDir) {
+    try {
+      fs.mkdirSync(logDir, { recursive: true });
+      logStream = fs.createWriteStream(path.join(logDir, 'fleet.log'), { flags: 'a' });
+    } catch {
+      logStream = null; // Fall back to stdout
+    }
+  }
+}
+
+function write(level, component, message) {
+  const ts = new Date().toISOString();
+  const line = `[${ts}] [${level}] [${component}] ${message}\n`;
+
+  initLogStream();
+  if (logStream) {
+    logStream.write(line);
+  }
+
+  // Also write to stderr for real-time visibility (MCP servers use stdout for protocol)
+  process.stderr.write(line);
+}
+
+export const log = {
+  info: (component, message) => write('INFO', component, message),
+  warn: (component, message) => write('WARN', component, message),
+  error: (component, message) => write('ERROR', component, message),
+};