@hybridaione/hybridclaw 0.1.5

package/src/health.ts

@@ -0,0 +1,189 @@
+import fs from 'fs';
+import http, { type IncomingMessage, type ServerResponse } from 'http';
+import path from 'path';
+
+import { HEALTH_HOST, HEALTH_PORT, WEB_API_TOKEN } from './config.js';
+import {
+  getGatewayHistory,
+  getGatewayStatus,
+  handleGatewayCommand,
+  handleGatewayMessage,
+  type GatewayCommandRequest,
+  type GatewayChatRequest,
+} from './gateway-service.js';
+import { logger } from './logger.js';
+
+const SITE_DIR = path.resolve(process.cwd(), 'docs');
+const MAX_REQUEST_BYTES = 1_000_000; // 1MB
+
+const MIME_TYPES: Record<string, string> = {
+  '.css': 'text/css; charset=utf-8',
+  '.html': 'text/html; charset=utf-8',
+  '.js': 'application/javascript; charset=utf-8',
+  '.json': 'application/json; charset=utf-8',
+  '.png': 'image/png',
+  '.svg': 'image/svg+xml',
+};
+
+function isLoopbackAddress(address: string | undefined): boolean {
+  if (!address) return false;
+  const normalized = address.replace(/^::ffff:/, '');
+  return normalized === '127.0.0.1' || normalized === '::1';
+}
+
+function hasApiAuth(req: IncomingMessage): boolean {
+  if (!WEB_API_TOKEN) {
+    return isLoopbackAddress(req.socket.remoteAddress);
+  }
+  const authHeader = req.headers.authorization || '';
+  return authHeader === `Bearer ${WEB_API_TOKEN}`;
+}
+
+function sendJson(res: ServerResponse, statusCode: number, payload: unknown): void {
+  res.writeHead(statusCode, { 'Content-Type': 'application/json; charset=utf-8' });
+  res.end(JSON.stringify(payload, null, 2));
+}
+
+function sendText(res: ServerResponse, statusCode: number, text: string): void {
+  res.writeHead(statusCode, { 'Content-Type': 'text/plain; charset=utf-8' });
+  res.end(text);
+}
+
+async function readJsonBody(req: IncomingMessage): Promise<unknown> {
+  const chunks: Buffer[] = [];
+  let total = 0;
+  for await (const chunk of req) {
+    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    total += buffer.length;
+    if (total > MAX_REQUEST_BYTES) {
+      throw new Error('Request body too large.');
+    }
+    chunks.push(buffer);
+  }
+  if (chunks.length === 0) return {};
+  const raw = Buffer.concat(chunks).toString('utf-8');
+  if (!raw.trim()) return {};
+  return JSON.parse(raw) as unknown;
+}
+
+function resolveSiteFile(pathname: string): string | null {
+  const cleanPath = pathname === '/' ? '/index.html' : pathname;
+  const normalized = path.normalize(cleanPath).replace(/^(\.\.(\/|\\|$))+/, '');
+  const candidate = path.resolve(SITE_DIR, `.${normalized}`);
+  if (!candidate.startsWith(SITE_DIR)) return null;
+  if (!fs.existsSync(candidate) || !fs.statSync(candidate).isFile()) return null;
+  return candidate;
+}
+
+function serveStatic(pathname: string, res: ServerResponse): boolean {
+  const filePath = resolveSiteFile(pathname === '/chat' ? '/chat.html' : pathname);
+  if (!filePath) return false;
+  const ext = path.extname(filePath).toLowerCase();
+  const mimeType = MIME_TYPES[ext] || 'application/octet-stream';
+  res.writeHead(200, { 'Content-Type': mimeType });
+  res.end(fs.readFileSync(filePath));
+  return true;
+}
+
+async function handleApiChat(req: IncomingMessage, res: ServerResponse): Promise<void> {
+  const body = await readJsonBody(req) as Partial<GatewayChatRequest>;
+
+  const content = body.content?.trim();
+  if (!content) {
+    sendJson(res, 400, { error: 'Missing `content` in request body.' });
+    return;
+  }
+
+  const chatRequest: GatewayChatRequest = {
+    sessionId: body.sessionId || 'web:default',
+    guildId: body.guildId ?? null,
+    channelId: body.channelId || 'web',
+    userId: body.userId || 'web-user',
+    username: body.username ?? 'web',
+    content,
+    chatbotId: body.chatbotId,
+    enableRag: body.enableRag,
+    model: body.model,
+  };
+  const result = await handleGatewayMessage(chatRequest);
+  sendJson(res, result.status === 'success' ? 200 : 500, result);
+}
+
+async function handleApiCommand(req: IncomingMessage, res: ServerResponse): Promise<void> {
+  const body = await readJsonBody(req) as Partial<GatewayCommandRequest>;
+  const args = Array.isArray(body.args) ? body.args.map((value) => String(value)) : [];
+  if (args.length === 0) {
+    sendJson(res, 400, { error: 'Missing command. Provide non-empty `args` array.' });
+    return;
+  }
+
+  const commandRequest: GatewayCommandRequest = {
+    sessionId: body.sessionId || 'web:default',
+    guildId: body.guildId ?? null,
+    channelId: body.channelId || 'web',
+    args,
+  };
+  const result = await handleGatewayCommand(commandRequest);
+  sendJson(res, result.kind === 'error' ? 400 : 200, result);
+}
+
+function handleApiHistory(res: ServerResponse, url: URL): void {
+  const sessionId = url.searchParams.get('sessionId') || 'web:default';
+  const parsedLimit = parseInt(url.searchParams.get('limit') || '40', 10);
+  const limit = Number.isNaN(parsedLimit) ? 40 : parsedLimit;
+  const history = getGatewayHistory(sessionId, limit);
+  sendJson(res, 200, { sessionId, history });
+}
+
+export function startHealthServer(): void {
+  const server = http.createServer((req, res) => {
+    const method = req.method || 'GET';
+    const url = new URL(req.url || '/', 'http://localhost');
+    const pathname = url.pathname;
+
+    if (pathname === '/health' && method === 'GET') {
+      sendJson(res, 200, getGatewayStatus());
+      return;
+    }
+
+    if (pathname.startsWith('/api/')) {
+      if (!hasApiAuth(req)) {
+        sendJson(res, 401, { error: 'Unauthorized. Set `Authorization: Bearer <WEB_API_TOKEN>`.' });
+        return;
+      }
+
+      void (async () => {
+        try {
+          if (pathname === '/api/status' && method === 'GET') {
+            sendJson(res, 200, getGatewayStatus());
+            return;
+          }
+          if (pathname === '/api/history' && method === 'GET') {
+            handleApiHistory(res, url);
+            return;
+          }
+          if (pathname === '/api/chat' && method === 'POST') {
+            await handleApiChat(req, res);
+            return;
+          }
+          if (pathname === '/api/command' && method === 'POST') {
+            await handleApiCommand(req, res);
+            return;
+          }
+          sendJson(res, 404, { error: 'Not Found' });
+        } catch (err) {
+          const errorText = err instanceof Error ? err.message : String(err);
+          sendJson(res, 500, { error: errorText });
+        }
+      })();
+      return;
+    }
+
+    if (serveStatic(pathname, res)) return;
+    sendText(res, 404, 'Not Found');
+  });
+
+  server.listen(HEALTH_PORT, HEALTH_HOST, () => {
+    logger.info({ host: HEALTH_HOST, port: HEALTH_PORT }, 'Gateway HTTP server started');
+  });
+}

package/src/heartbeat.ts

@@ -0,0 +1,121 @@
+/**
+ * Heartbeat — periodic poll so the agent can proactively check tasks,
+ * maintain memory, and reach out when needed.
+ */
+import { HEARTBEAT_CHANNEL, HEARTBEAT_ENABLED, HYBRIDAI_CHATBOT_ID, HYBRIDAI_ENABLE_RAG, HYBRIDAI_MODEL } from './config.js';
+import { runAgent } from './agent.js';
+import { getConversationHistory, getOrCreateSession, getTasksForSession, storeMessage } from './db.js';
+import { logger } from './logger.js';
+import { processSideEffects } from './side-effects.js';
+import { maybeCompactSession } from './session-maintenance.js';
+import { appendSessionTranscript } from './session-transcripts.js';
+import { buildConversationContext } from './conversation.js';
+
+const HEARTBEAT_PROMPT =
+  '[Heartbeat poll] Check HEARTBEAT.md for periodic tasks. If nothing needs attention, reply HEARTBEAT_OK.';
+
+const MAX_HEARTBEAT_HISTORY = 5;
+
+let timer: ReturnType<typeof setInterval> | null = null;
+let running = false;
+
+function isHeartbeatOk(text: string): boolean {
+  const normalized = text.trim().replace(/[^a-z_]/gi, '').toUpperCase();
+  return normalized === 'HEARTBEATOK' || normalized.startsWith('HEARTBEATOK');
+}
+
+export function startHeartbeat(
+  agentId: string,
+  interval: number,
+  onMessage: (text: string) => void,
+): void {
+  if (!HEARTBEAT_ENABLED) {
+    logger.info('Heartbeat disabled via HEARTBEAT_ENABLED=false');
+    return;
+  }
+
+  logger.info({ interval }, 'Heartbeat started');
+
+  timer = setInterval(async () => {
+    if (running) {
+      logger.debug('Heartbeat skipped — previous still running');
+      return;
+    }
+    running = true;
+
+    const sessionId = `heartbeat:${agentId}`;
+    const channelId = 'heartbeat';
+
+    try {
+      const session = getOrCreateSession(sessionId, null, channelId);
+
+      const history = getConversationHistory(sessionId, MAX_HEARTBEAT_HISTORY);
+      const { messages } = buildConversationContext({
+        agentId,
+        sessionSummary: session.session_summary,
+        history,
+      });
+      messages.push({ role: 'user', content: HEARTBEAT_PROMPT });
+
+      const chatbotId = HYBRIDAI_CHATBOT_ID || agentId;
+      const heartbeatChannelId = HEARTBEAT_CHANNEL || 'heartbeat';
+      const scheduledTasks = getTasksForSession(sessionId);
+      const output = await runAgent(sessionId, messages, chatbotId, HYBRIDAI_ENABLE_RAG, HYBRIDAI_MODEL, agentId, heartbeatChannelId, scheduledTasks);
+      processSideEffects(output, sessionId, heartbeatChannelId);
+
+      if (output.status === 'error') {
+        logger.warn({ error: output.error }, 'Heartbeat agent error');
+        return;
+      }
+
+      const result = (output.result || '').trim();
+
+      if (isHeartbeatOk(result)) {
+        logger.debug('Heartbeat: HEARTBEAT_OK — nothing to do');
+        return;
+      }
+
+      // Real content — persist and deliver
+      storeMessage(sessionId, 'heartbeat', 'heartbeat', 'user', HEARTBEAT_PROMPT);
+      storeMessage(sessionId, 'assistant', null, 'assistant', result);
+      appendSessionTranscript(agentId, {
+        sessionId,
+        channelId: heartbeatChannelId,
+        role: 'user',
+        userId: 'heartbeat',
+        username: 'heartbeat',
+        content: HEARTBEAT_PROMPT,
+      });
+      appendSessionTranscript(agentId, {
+        sessionId,
+        channelId: heartbeatChannelId,
+        role: 'assistant',
+        userId: 'assistant',
+        username: null,
+        content: result,
+      });
+      await maybeCompactSession({
+        sessionId,
+        agentId,
+        chatbotId,
+        enableRag: HYBRIDAI_ENABLE_RAG,
+        model: HYBRIDAI_MODEL,
+        channelId: heartbeatChannelId,
+      });
+      logger.info({ length: result.length }, 'Heartbeat: agent has something to say');
+      onMessage(result);
+    } catch (err) {
+      logger.error({ err }, 'Heartbeat failed');
+    } finally {
+      running = false;
+    }
+  }, interval);
+}
+
+export function stopHeartbeat(): void {
+  if (timer) {
+    clearInterval(timer);
+    timer = null;
+    logger.info('Heartbeat stopped');
+  }
+}

package/src/hybridai-bots.ts

@@ -0,0 +1,48 @@
+import { HYBRIDAI_API_KEY, HYBRIDAI_BASE_URL } from './config.js';
+import type { HybridAIBot } from './types.js';
+
+interface BotCacheEntry {
+  bots: HybridAIBot[];
+  fetchedAtMs: number;
+}
+
+let botCache: BotCacheEntry | null = null;
+
+function normalizeBots(payload: unknown): HybridAIBot[] {
+  const data = payload as
+    | { data?: Record<string, unknown>[]; bots?: Record<string, unknown>[]; items?: Record<string, unknown>[] }
+    | Record<string, unknown>[];
+  const raw = Array.isArray(data) ? data : (data.data || data.bots || data.items || []);
+
+  return raw.map((item) => ({
+    id: String(item.id ?? item._id ?? item.chatbot_id ?? item.bot_id ?? ''),
+    name: String(item.bot_name ?? item.name ?? 'Unnamed'),
+    description: item.description != null ? String(item.description) : undefined,
+  }));
+}
+
+export async function fetchHybridAIBots(options?: { cacheTtlMs?: number }): Promise<HybridAIBot[]> {
+  const cacheTtlMs = Math.max(0, options?.cacheTtlMs ?? 0);
+  const now = Date.now();
+
+  if (cacheTtlMs > 0 && botCache && now - botCache.fetchedAtMs < cacheTtlMs) {
+    return botCache.bots;
+  }
+
+  const url = `${HYBRIDAI_BASE_URL}/api/v1/bot-management/bots`;
+  const res = await fetch(url, {
+    headers: { Authorization: `Bearer ${HYBRIDAI_API_KEY}` },
+  });
+
+  if (!res.ok) {
+    throw new Error(`Failed to fetch bots: ${res.status} ${res.statusText}`);
+  }
+
+  const bots = normalizeBots(await res.json());
+  if (cacheTtlMs > 0) {
+    botCache = { bots, fetchedAtMs: now };
+  } else {
+    botCache = null;
+  }
+  return bots;
+}

package/src/ipc.ts

@@ -0,0 +1,163 @@
+import fs from 'fs';
+import path from 'path';
+
+import { CONTAINER_MAX_OUTPUT_SIZE, DATA_DIR } from './config.js';
+import { logger } from './logger.js';
+import type { ContainerInput, ContainerOutput } from './types.js';
+
+/**
+ * Get session directory, creating it if needed.
+ */
+function sessionDir(sessionId: string): string {
+  const safe = sessionId.replace(/[^a-zA-Z0-9_-]/g, '_');
+  const dir = path.join(DATA_DIR, 'sessions', safe);
+  return dir;
+}
+
+function ipcDir(sessionId: string): string {
+  return path.join(sessionDir(sessionId), 'ipc');
+}
+
+function agentDir(agentId: string): string {
+  const safe = agentId.replace(/[^a-zA-Z0-9_-]/g, '_');
+  return path.join(DATA_DIR, 'agents', safe);
+}
+
+export function agentWorkspaceDir(agentId: string): string {
+  return path.join(agentDir(agentId), 'workspace');
+}
+
+/**
+ * Ensure session directories exist (IPC only).
+ */
+export function ensureSessionDirs(sessionId: string): void {
+  fs.mkdirSync(ipcDir(sessionId), { recursive: true });
+}
+
+/**
+ * Ensure agent workspace directory exists.
+ */
+export function ensureAgentDirs(agentId: string): void {
+  fs.mkdirSync(agentWorkspaceDir(agentId), { recursive: true });
+}
+
+/**
+ * Write input for the container agent.
+ * When omitApiKey is set, the apiKey field is excluded from the file on disk
+ * (the container already has the key in memory from the initial stdin payload).
+ */
+export function writeInput(sessionId: string, input: ContainerInput, opts?: { omitApiKey?: boolean }): string {
+  const dir = ipcDir(sessionId);
+  const inputPath = path.join(dir, 'input.json');
+  const toWrite = opts?.omitApiKey ? { ...input, apiKey: '' } : input;
+  fs.writeFileSync(inputPath, JSON.stringify(toWrite, null, 2));
+  logger.debug({ sessionId, path: inputPath }, 'Wrote IPC input');
+  return inputPath;
+}
+
+/**
+ * Read output from the container agent. Polls until file appears or timeout.
+ */
+function interruptedOutput(): ContainerOutput {
+  return {
+    status: 'error',
+    result: null,
+    toolsUsed: [],
+    error: 'Interrupted by user.',
+  };
+}
+
+async function sleepWithAbort(ms: number, signal?: AbortSignal): Promise<boolean> {
+  if (!signal) {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+    return false;
+  }
+  if (signal.aborted) return true;
+
+  return new Promise((resolve) => {
+    const timer = setTimeout(() => {
+      signal.removeEventListener('abort', onAbort);
+      resolve(false);
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      signal.removeEventListener('abort', onAbort);
+      resolve(true);
+    };
+    signal.addEventListener('abort', onAbort, { once: true });
+  });
+}
+
+export async function readOutput(
+  sessionId: string,
+  timeoutMs: number,
+  opts?: { signal?: AbortSignal },
+): Promise<ContainerOutput> {
+  const dir = ipcDir(sessionId);
+  const outputPath = path.join(dir, 'output.json');
+  const signal = opts?.signal;
+
+  const start = Date.now();
+  const pollInterval = 250;
+
+  if (signal?.aborted) return interruptedOutput();
+
+  while (Date.now() - start < timeoutMs) {
+    if (signal?.aborted) return interruptedOutput();
+
+    if (fs.existsSync(outputPath)) {
+      const stat = fs.statSync(outputPath);
+      if (stat.size > CONTAINER_MAX_OUTPUT_SIZE) {
+        fs.unlinkSync(outputPath);
+        logger.warn({ sessionId, size: stat.size, limit: CONTAINER_MAX_OUTPUT_SIZE }, 'Container output exceeded size limit');
+        return { status: 'error', result: null, toolsUsed: [], error: `Output too large (${stat.size} bytes, limit ${CONTAINER_MAX_OUTPUT_SIZE})` };
+      }
+      try {
+        const raw = fs.readFileSync(outputPath, 'utf-8');
+        const output: ContainerOutput = JSON.parse(raw);
+        // Clean up output file after reading
+        fs.unlinkSync(outputPath);
+        logger.debug({ sessionId }, 'Read IPC output');
+        return output;
+      } catch (err) {
+        // File might be partially written, wait and retry
+        logger.debug({ sessionId, err }, 'Output file not ready, retrying');
+      }
+    }
+    const aborted = await sleepWithAbort(pollInterval, signal);
+    if (aborted) return interruptedOutput();
+  }
+
+  return {
+    status: 'error',
+    result: null,
+    toolsUsed: [],
+    error: `Timeout waiting for container output after ${timeoutMs}ms`,
+  };
+}
+
+/**
+ * Clean up IPC files for a session.
+ */
+export function cleanupIpc(sessionId: string): void {
+  const dir = ipcDir(sessionId);
+  for (const file of ['input.json', 'output.json', 'history.json']) {
+    const filePath = path.join(dir, file);
+    if (fs.existsSync(filePath)) {
+      fs.unlinkSync(filePath);
+    }
+  }
+}
+
+/**
+ * Get host paths for container mounting.
+ */
+export function getSessionPaths(sessionId: string, agentId: string): {
+  ipcPath: string;
+  workspacePath: string;
+} {
+  return {
+    ipcPath: path.resolve(ipcDir(sessionId)),
+    workspacePath: path.resolve(agentWorkspaceDir(agentId)),
+  };
+}

package/src/logger.ts

@@ -0,0 +1,26 @@
+import pino from 'pino';
+
+import { getRuntimeConfig, onRuntimeConfigChange } from './runtime-config.js';
+
+const initialLevel = getRuntimeConfig().ops.logLevel;
+
+export const logger = pino({
+  level: initialLevel,
+  transport: { target: 'pino-pretty', options: { colorize: true } },
+});
+
+onRuntimeConfigChange((next, prev) => {
+  if (next.ops.logLevel !== prev.ops.logLevel) {
+    logger.level = next.ops.logLevel;
+    logger.info({ level: next.ops.logLevel }, 'Logger level updated from config.json');
+  }
+});
+
+process.on('uncaughtException', (err) => {
+  logger.fatal({ err }, 'Uncaught exception');
+  process.exit(1);
+});
+
+process.on('unhandledRejection', (reason) => {
+  logger.error({ err: reason }, 'Unhandled rejection');
+});