@hybridaione/hybridclaw 0.1.5

package/src/container-runner.ts

@@ -0,0 +1,305 @@
+/**
+ * Container Runner — manages a pool of persistent containers.
+ * Containers stay alive between requests and exit after an idle timeout.
+ */
+import { ChildProcess, spawn } from 'child_process';
+
+import {
+  ADDITIONAL_MOUNTS,
+  CONTAINER_CPUS,
+  CONTAINER_IMAGE,
+  CONTAINER_MEMORY,
+  CONTAINER_TIMEOUT,
+  HYBRIDAI_API_KEY,
+  HYBRIDAI_BASE_URL,
+  HYBRIDAI_MODEL,
+  MAX_CONCURRENT_CONTAINERS,
+} from './config.js';
+import { cleanupIpc, ensureAgentDirs, ensureSessionDirs, getSessionPaths, readOutput, writeInput } from './ipc.js';
+import { logger } from './logger.js';
+import { validateAdditionalMounts } from './mount-security.js';
+import type { AdditionalMount, ChatMessage, ContainerInput, ContainerOutput, ScheduledTask, ToolProgressEvent } from './types.js';
+
+const IDLE_TIMEOUT_MS = 300_000; // 5 minutes — matches container-side default
+
+interface PoolEntry {
+  process: ChildProcess;
+  containerName: string;
+  sessionId: string;
+  startedAt: number;
+  stderrBuffer: string;
+  onToolProgress?: (event: ToolProgressEvent) => void;
+}
+
+const pool = new Map<string, PoolEntry>();
+const TOOL_RESULT_RE = /^\[tool\]\s+([a-zA-Z0-9_.-]+)\s+result\s+\((\d+)ms\):\s*(.*)$/;
+const TOOL_START_RE = /^\[tool\]\s+([a-zA-Z0-9_.-]+):\s*(.*)$/;
+
+function emitToolProgress(entry: PoolEntry, line: string): void {
+  const callback = entry.onToolProgress;
+  if (!callback) return;
+
+  const resultMatch = line.match(TOOL_RESULT_RE);
+  if (resultMatch) {
+    try {
+      callback({
+        sessionId: entry.sessionId,
+        toolName: resultMatch[1],
+        phase: 'finish',
+        durationMs: parseInt(resultMatch[2], 10),
+        preview: resultMatch[3],
+      });
+    } catch (err) {
+      logger.debug({ sessionId: entry.sessionId, err }, 'Tool progress callback failed');
+    }
+    return;
+  }
+
+  const startMatch = line.match(TOOL_START_RE);
+  if (startMatch) {
+    try {
+      callback({
+        sessionId: entry.sessionId,
+        toolName: startMatch[1],
+        phase: 'start',
+        preview: startMatch[2],
+      });
+    } catch (err) {
+      logger.debug({ sessionId: entry.sessionId, err }, 'Tool progress callback failed');
+    }
+  }
+}
+
+export function getActiveContainerCount(): number {
+  return pool.size;
+}
+
+function stopContainer(containerName: string): void {
+  const proc = spawn('docker', ['stop', containerName], { stdio: 'ignore' });
+  proc.on('error', (err) => {
+    logger.debug({ containerName, err }, 'Failed to stop container');
+  });
+}
+
+/**
+ * Get or spawn a persistent container for a session.
+ */
+function getOrSpawnContainer(sessionId: string, agentId: string): PoolEntry {
+  const existing = pool.get(sessionId);
+  if (existing && !existing.process.killed && existing.process.exitCode === null) {
+    logger.debug({ sessionId, containerName: existing.containerName }, 'Reusing container');
+    return existing;
+  }
+
+  // Clean up stale entry
+  if (existing) {
+    pool.delete(sessionId);
+  }
+
+  ensureSessionDirs(sessionId);
+  ensureAgentDirs(agentId);
+  const { ipcPath, workspacePath } = getSessionPaths(sessionId, agentId);
+  const containerName = `hybridclaw-${sessionId.replace(/[^a-zA-Z0-9-]/g, '-')}-${Date.now()}`;
+
+  const args = [
+    'run',
+    '--rm',
+    '-i',
+    '--name', containerName,
+    '--memory', CONTAINER_MEMORY,
+    `--cpus=${CONTAINER_CPUS}`,
+    '--read-only',
+    '--tmpfs', '/tmp',
+    '-v', `${workspacePath}:/workspace:rw`,
+    '-v', `${ipcPath}:/ipc:rw`,
+    '-e', `HYBRIDAI_BASE_URL=${HYBRIDAI_BASE_URL}`,
+    '-e', `HYBRIDAI_MODEL=${HYBRIDAI_MODEL}`,
+    '-e', `CONTAINER_IDLE_TIMEOUT=${IDLE_TIMEOUT_MS}`,
+  ];
+
+  // Run as host user so bind-mount file ownership matches
+  const hostUid = process.getuid?.();
+  const hostGid = process.getgid?.();
+  if (hostUid != null && hostUid !== 0 && hostUid !== 1000) {
+    args.push('--user', `${hostUid}:${hostGid}`);
+    args.push('-e', 'HOME=/home/node');
+  }
+
+  // Validate and append additional mounts
+  if (ADDITIONAL_MOUNTS) {
+    try {
+      const requested = JSON.parse(ADDITIONAL_MOUNTS) as AdditionalMount[];
+      const validated = validateAdditionalMounts(requested);
+      for (const m of validated) {
+        args.push('-v', `${m.hostPath}:${m.containerPath}:${m.readonly ? 'ro' : 'rw'}`);
+      }
+    } catch (err) {
+      logger.warn({ error: err instanceof Error ? err.message : String(err) }, 'Failed to parse ADDITIONAL_MOUNTS');
+    }
+  }
+
+  args.push(CONTAINER_IMAGE);
+
+  logger.info({ sessionId, containerName }, 'Spawning persistent container');
+
+  const proc = spawn('docker', args, {
+    stdio: ['pipe', 'pipe', 'pipe'],
+  });
+
+  const entry: PoolEntry = {
+    process: proc,
+    containerName,
+    sessionId,
+    startedAt: Date.now(),
+    stderrBuffer: '',
+  };
+
+  proc.stderr.on('data', (data) => {
+    entry.stderrBuffer += data.toString('utf-8');
+    const lines = entry.stderrBuffer.split('\n');
+    entry.stderrBuffer = lines.pop() || '';
+    for (const rawLine of lines) {
+      const line = rawLine.trim();
+      if (!line) continue;
+      logger.debug({ container: containerName }, line);
+      emitToolProgress(entry, line);
+    }
+  });
+
+  proc.on('close', (code) => {
+    const tail = entry.stderrBuffer.trim();
+    if (tail) {
+      logger.debug({ container: containerName }, tail);
+      emitToolProgress(entry, tail);
+      entry.stderrBuffer = '';
+    }
+    pool.delete(sessionId);
+    logger.info({ sessionId, containerName, code }, 'Container exited');
+  });
+
+  proc.on('error', (err) => {
+    pool.delete(sessionId);
+    logger.error({ sessionId, containerName, error: err }, 'Container error');
+  });
+
+  pool.set(sessionId, entry);
+  return entry;
+}
+
+/**
+ * Send a request to a persistent container and wait for the response.
+ */
+export async function runContainer(
+  sessionId: string,
+  messages: ChatMessage[],
+  chatbotId: string,
+  enableRag: boolean,
+  model: string = HYBRIDAI_MODEL,
+  agentId: string = chatbotId,
+  channelId: string = '',
+  scheduledTasks?: ScheduledTask[],
+  allowedTools?: string[],
+  onToolProgress?: (event: ToolProgressEvent) => void,
+  abortSignal?: AbortSignal,
+): Promise<ContainerOutput> {
+  // Enforce concurrent container limit
+  if (pool.size >= MAX_CONCURRENT_CONTAINERS && !pool.has(sessionId)) {
+    return {
+      status: 'error',
+      result: null,
+      toolsUsed: [],
+      error: `Too many active containers (${pool.size}/${MAX_CONCURRENT_CONTAINERS}). Try again later.`,
+    };
+  }
+
+  const startTime = Date.now();
+
+  // Clean any stale output from previous request
+  cleanupIpc(sessionId);
+  ensureSessionDirs(sessionId);
+
+  const isNewContainer = !pool.has(sessionId) || pool.get(sessionId)!.process.killed || pool.get(sessionId)!.process.exitCode !== null;
+
+  let entry: PoolEntry;
+  try {
+    entry = getOrSpawnContainer(sessionId, agentId);
+  } catch (err) {
+    return {
+      status: 'error',
+      result: null,
+      toolsUsed: [],
+      error: `Container spawn error: ${err instanceof Error ? err.message : String(err)}`,
+    };
+  }
+
+  const input: ContainerInput = {
+    sessionId,
+    messages,
+    chatbotId,
+    enableRag,
+    apiKey: HYBRIDAI_API_KEY,
+    baseUrl: HYBRIDAI_BASE_URL.replace(/\/\/(localhost|127\.0\.0\.1)([:\/])/, '//host.docker.internal$2'),
+    model,
+    channelId,
+    scheduledTasks: scheduledTasks?.map((t) => ({
+      id: t.id,
+      cronExpr: t.cron_expr,
+      runAt: t.run_at,
+      everyMs: t.every_ms,
+      prompt: t.prompt,
+      enabled: t.enabled,
+      lastRun: t.last_run,
+      createdAt: t.created_at,
+    })),
+    allowedTools,
+  };
+
+  entry.onToolProgress = onToolProgress;
+  const onAbort = () => {
+    logger.info({ sessionId, containerName: entry.containerName }, 'Interrupt requested, stopping container');
+    stopContainer(entry.containerName);
+  };
+  if (abortSignal) {
+    abortSignal.addEventListener('abort', onAbort, { once: true });
+    if (abortSignal.aborted) onAbort();
+  }
+
+  try {
+    if (isNewContainer) {
+      // First request: send full input (including apiKey) via stdin — no file on disk.
+      // Write JSON on a single line followed by newline as delimiter.
+      // Do NOT end stdin — closing stdin can cause docker -i to terminate the container.
+      entry.process.stdin?.write(JSON.stringify(input) + '\n');
+    } else {
+      // Follow-up requests: write to IPC file, omitting apiKey
+      writeInput(sessionId, input, { omitApiKey: true });
+    }
+
+    // Wait for the container to produce output
+    const output = await readOutput(sessionId, CONTAINER_TIMEOUT, { signal: abortSignal });
+    const duration = Date.now() - startTime;
+
+    logger.info(
+      { sessionId, containerName: entry.containerName, duration, status: output.status, toolsUsed: output.toolsUsed },
+      'Request completed',
+    );
+
+    return output;
+  } finally {
+    abortSignal?.removeEventListener('abort', onAbort);
+    if (entry.onToolProgress === onToolProgress) {
+      entry.onToolProgress = undefined;
+    }
+  }
+}
+
+/**
+ * Stop all containers (for graceful shutdown).
+ */
+export function stopAllContainers(): void {
+  for (const [sessionId, entry] of pool) {
+    logger.info({ sessionId, containerName: entry.containerName }, 'Stopping container (shutdown)');
+    stopContainer(entry.containerName);
+  }
+  pool.clear();
+}

package/src/conversation.ts

@@ -0,0 +1,49 @@
+import { expandSkillInvocation, loadSkills, type Skill } from './skills.js';
+import type { ChatMessage } from './types.js';
+import { buildSystemPromptFromHooks } from './prompt-hooks.js';
+
+interface HistoryMessage {
+  role: string;
+  content: string;
+}
+
+export interface ConversationContext {
+  messages: ChatMessage[];
+  skills: Skill[];
+}
+
+export function buildConversationContext(params: {
+  agentId: string;
+  sessionSummary?: string | null;
+  history: HistoryMessage[];
+  expandLatestHistoryUser?: boolean;
+}): ConversationContext {
+  const { agentId, sessionSummary, history, expandLatestHistoryUser = false } = params;
+  const skills = loadSkills(agentId);
+  const systemPrompt = buildSystemPromptFromHooks({
+    agentId,
+    sessionSummary,
+    skills,
+    purpose: 'conversation',
+  });
+
+  const messages: ChatMessage[] = [];
+  if (systemPrompt) {
+    messages.push({ role: 'system', content: systemPrompt });
+  }
+
+  const historyMessages = [...history].reverse().map((msg): ChatMessage => ({
+    role: msg.role as ChatMessage['role'],
+    content: msg.content,
+  }));
+
+  if (expandLatestHistoryUser && historyMessages.length > 0) {
+    const latest = historyMessages[historyMessages.length - 1];
+    if (latest.role === 'user' && typeof latest.content === 'string') {
+      latest.content = expandSkillInvocation(latest.content, skills);
+    }
+  }
+
+  messages.push(...historyMessages);
+  return { messages, skills };
+}

package/src/db.ts

@@ -0,0 +1,290 @@
+import Database from 'better-sqlite3';
+import fs from 'fs';
+import path from 'path';
+
+import { DB_PATH } from './config.js';
+import { logger } from './logger.js';
+import type { AuditEntry, ScheduledTask, Session, StoredMessage } from './types.js';
+
+let db: Database.Database;
+
+function createSchema(database: Database.Database): void {
+  database.exec(`
+    CREATE TABLE IF NOT EXISTS sessions (
+      id TEXT PRIMARY KEY,
+      guild_id TEXT,
+      channel_id TEXT NOT NULL,
+      chatbot_id TEXT,
+      model TEXT,
+      enable_rag INTEGER DEFAULT 1,
+      message_count INTEGER DEFAULT 0,
+      session_summary TEXT,
+      summary_updated_at TEXT,
+      compaction_count INTEGER DEFAULT 0,
+      memory_flush_at TEXT,
+      created_at TEXT DEFAULT (datetime('now')),
+      last_active TEXT DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS messages (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL,
+      user_id TEXT NOT NULL,
+      username TEXT,
+      role TEXT NOT NULL,
+      content TEXT NOT NULL,
+      created_at TEXT DEFAULT (datetime('now'))
+    );
+    CREATE INDEX IF NOT EXISTS idx_messages_session ON messages(session_id);
+
+    CREATE TABLE IF NOT EXISTS tasks (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL,
+      channel_id TEXT NOT NULL,
+      cron_expr TEXT NOT NULL,
+      prompt TEXT NOT NULL,
+      enabled INTEGER DEFAULT 1,
+      last_run TEXT,
+      created_at TEXT DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS audit_log (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT,
+      event TEXT NOT NULL,
+      detail TEXT,
+      duration_ms INTEGER,
+      created_at TEXT DEFAULT (datetime('now'))
+    );
+    CREATE INDEX IF NOT EXISTS idx_audit_session ON audit_log(session_id);
+    CREATE INDEX IF NOT EXISTS idx_audit_created ON audit_log(created_at);
+  `);
+}
+
+function migrateSchema(database: Database.Database): void {
+  const addColumnIfMissing = (table: string, column: string, ddl: string): void => {
+    const cols = database.pragma(`table_info(${table})`) as Array<{ name: string }>;
+    if (!cols.some((c) => c.name === column)) {
+      database.exec(`ALTER TABLE ${table} ADD COLUMN ${ddl}`);
+      logger.info({ table, column }, 'Migrated table: added column');
+    }
+  };
+
+  // Add session columns if they don't exist
+  const sessionCols = database.pragma('table_info(sessions)') as Array<{ name: string }>;
+  if (!sessionCols.some((c) => c.name === 'model')) {
+    database.exec('ALTER TABLE sessions ADD COLUMN model TEXT');
+    logger.info('Migrated sessions table: added model column');
+  }
+  addColumnIfMissing('sessions', 'session_summary', 'session_summary TEXT');
+  addColumnIfMissing('sessions', 'summary_updated_at', 'summary_updated_at TEXT');
+  addColumnIfMissing('sessions', 'compaction_count', 'compaction_count INTEGER DEFAULT 0');
+  addColumnIfMissing('sessions', 'memory_flush_at', 'memory_flush_at TEXT');
+
+  // Add run_at and every_ms columns to tasks if they don't exist
+  const taskCols = database.pragma('table_info(tasks)') as Array<{ name: string }>;
+  if (!taskCols.some((c) => c.name === 'run_at')) {
+    database.exec('ALTER TABLE tasks ADD COLUMN run_at TEXT');
+    logger.info('Migrated tasks table: added run_at column');
+  }
+  if (!taskCols.some((c) => c.name === 'every_ms')) {
+    database.exec('ALTER TABLE tasks ADD COLUMN every_ms INTEGER');
+    logger.info('Migrated tasks table: added every_ms column');
+  }
+}
+
+export function initDatabase(): void {
+  const dbPath = path.resolve(DB_PATH);
+  fs.mkdirSync(path.dirname(dbPath), { recursive: true });
+  db = new Database(dbPath);
+  db.pragma('journal_mode = WAL');
+  createSchema(db);
+  migrateSchema(db);
+  logger.info({ path: dbPath }, 'Database initialized');
+}
+
+// --- Sessions ---
+
+export function getOrCreateSession(
+  sessionId: string,
+  guildId: string | null,
+  channelId: string,
+): Session {
+  const existing = getSessionById(sessionId);
+
+  if (existing) {
+    db.prepare('UPDATE sessions SET last_active = datetime(\'now\') WHERE id = ?').run(sessionId);
+    return existing;
+  }
+
+  db.prepare(
+    'INSERT INTO sessions (id, guild_id, channel_id) VALUES (?, ?, ?)',
+  ).run(sessionId, guildId, channelId);
+
+  return getSessionById(sessionId) as Session;
+}
+
+export function getSessionById(sessionId: string): Session | undefined {
+  return db
+    .prepare('SELECT * FROM sessions WHERE id = ?')
+    .get(sessionId) as Session | undefined;
+}
+
+export function updateSessionChatbot(sessionId: string, chatbotId: string | null): void {
+  db.prepare('UPDATE sessions SET chatbot_id = ? WHERE id = ?').run(chatbotId, sessionId);
+}
+
+export function updateSessionModel(sessionId: string, model: string | null): void {
+  db.prepare('UPDATE sessions SET model = ? WHERE id = ?').run(model, sessionId);
+}
+
+export function updateSessionRag(sessionId: string, enableRag: boolean): void {
+  db.prepare('UPDATE sessions SET enable_rag = ? WHERE id = ?').run(enableRag ? 1 : 0, sessionId);
+}
+
+export function getAllSessions(): Session[] {
+  return db.prepare('SELECT * FROM sessions ORDER BY last_active DESC').all() as Session[];
+}
+
+export function getSessionCount(): number {
+  const row = db.prepare('SELECT COUNT(*) as count FROM sessions').get() as { count: number };
+  return row.count;
+}
+
+export function clearSessionHistory(sessionId: string): number {
+  const result = db.prepare('DELETE FROM messages WHERE session_id = ?').run(sessionId);
+  db.prepare(
+    'UPDATE sessions SET message_count = 0, session_summary = NULL, summary_updated_at = NULL, compaction_count = 0, memory_flush_at = NULL WHERE id = ?',
+  ).run(sessionId);
+  return result.changes;
+}
+
+// --- Messages ---
+
+export function storeMessage(
+  sessionId: string,
+  userId: string,
+  username: string | null,
+  role: string,
+  content: string,
+): void {
+  db.prepare(
+    'INSERT INTO messages (session_id, user_id, username, role, content) VALUES (?, ?, ?, ?, ?)',
+  ).run(sessionId, userId, username, role, content);
+
+  db.prepare(
+    'UPDATE sessions SET message_count = message_count + 1, last_active = datetime(\'now\') WHERE id = ?',
+  ).run(sessionId);
+}
+
+export function getConversationHistory(sessionId: string, limit = 50): StoredMessage[] {
+  return db
+    .prepare(
+      'SELECT * FROM messages WHERE session_id = ? ORDER BY id DESC LIMIT ?',
+    )
+    .all(sessionId, limit) as StoredMessage[];
+}
+
+export interface CompactionCandidate {
+  cutoffId: number;
+  olderMessages: StoredMessage[];
+}
+
+export function getCompactionCandidateMessages(
+  sessionId: string,
+  keepRecent: number,
+): CompactionCandidate | null {
+  const keep = Math.max(1, Math.floor(keepRecent));
+  const cutoffRow = db
+    .prepare('SELECT id FROM messages WHERE session_id = ? ORDER BY id DESC LIMIT 1 OFFSET ?')
+    .get(sessionId, keep - 1) as { id: number } | undefined;
+  if (!cutoffRow) return null;
+
+  const older = db
+    .prepare('SELECT * FROM messages WHERE session_id = ? AND id < ? ORDER BY id ASC')
+    .all(sessionId, cutoffRow.id) as StoredMessage[];
+  if (older.length === 0) return null;
+
+  return {
+    cutoffId: cutoffRow.id,
+    olderMessages: older,
+  };
+}
+
+export function deleteMessagesBeforeId(sessionId: string, cutoffId: number): number {
+  const result = db
+    .prepare('DELETE FROM messages WHERE session_id = ? AND id < ?')
+    .run(sessionId, cutoffId);
+  db.prepare(
+    'UPDATE sessions SET message_count = (SELECT COUNT(*) FROM messages WHERE session_id = ?), last_active = datetime(\'now\') WHERE id = ?',
+  ).run(sessionId, sessionId);
+  return result.changes;
+}
+
+export function updateSessionSummary(sessionId: string, summary: string): void {
+  const normalized = summary.trim();
+  db.prepare(
+    'UPDATE sessions SET session_summary = ?, summary_updated_at = datetime(\'now\'), compaction_count = compaction_count + 1 WHERE id = ?',
+  ).run(normalized || null, sessionId);
+}
+
+export function markSessionMemoryFlush(sessionId: string): void {
+  db.prepare('UPDATE sessions SET memory_flush_at = datetime(\'now\') WHERE id = ?').run(sessionId);
+}
+
+// --- Tasks ---
+
+export function createTask(
+  sessionId: string,
+  channelId: string,
+  cronExpr: string,
+  prompt: string,
+  runAt?: string,
+  everyMs?: number,
+): number {
+  const result = db.prepare(
+    'INSERT INTO tasks (session_id, channel_id, cron_expr, prompt, run_at, every_ms) VALUES (?, ?, ?, ?, ?, ?)',
+  ).run(sessionId, channelId, cronExpr, prompt, runAt || null, everyMs || null);
+  return result.lastInsertRowid as number;
+}
+
+export function getTasksForSession(sessionId: string): ScheduledTask[] {
+  return db
+    .prepare('SELECT * FROM tasks WHERE session_id = ? ORDER BY created_at DESC')
+    .all(sessionId) as ScheduledTask[];
+}
+
+export function getAllEnabledTasks(): ScheduledTask[] {
+  return db.prepare('SELECT * FROM tasks WHERE enabled = 1').all() as ScheduledTask[];
+}
+
+export function updateTaskLastRun(taskId: number): void {
+  db.prepare('UPDATE tasks SET last_run = datetime(\'now\') WHERE id = ?').run(taskId);
+}
+
+export function toggleTask(taskId: number, enabled: boolean): void {
+  db.prepare('UPDATE tasks SET enabled = ? WHERE id = ?').run(enabled ? 1 : 0, taskId);
+}
+
+export function deleteTask(taskId: number): void {
+  db.prepare('DELETE FROM tasks WHERE id = ?').run(taskId);
+}
+
+// --- Audit ---
+
+export function logAudit(
+  event: string,
+  sessionId?: string,
+  detail?: Record<string, unknown>,
+  durationMs?: number,
+): void {
+  db.prepare(
+    'INSERT INTO audit_log (session_id, event, detail, duration_ms) VALUES (?, ?, ?, ?)',
+  ).run(sessionId || null, event, detail ? JSON.stringify(detail) : null, durationMs || null);
+}
+
+export function getRecentAudit(limit = 20): AuditEntry[] {
+  return db
+    .prepare('SELECT * FROM audit_log ORDER BY created_at DESC LIMIT ?')
+    .all(limit) as AuditEntry[];
+}