@hybridaione/hybridclaw 0.1.5

package/src/tui.ts

@@ -0,0 +1,327 @@
+/**
+ * HybridClaw TUI — thin client for the gateway API.
+ * Usage: npm run tui
+ */
+import readline from 'readline';
+
+import { APP_VERSION, GATEWAY_BASE_URL, HYBRIDAI_BASE_URL, HYBRIDAI_CHATBOT_ID, HYBRIDAI_MODEL } from './config.js';
+import {
+  gatewayChat,
+  gatewayCommand,
+  gatewayStatus,
+  renderGatewayCommand,
+  type GatewayCommandResult,
+} from './gateway-client.js';
+import { logger } from './logger.js';
+
+const RESET = '\x1b[0m';
+const BOLD = '\x1b[1m';
+const DIM = '\x1b[2m';
+const TEAL = '\x1b[38;2;92;224;216m';
+const NAVY = '\x1b[38;2;30;58;95m';
+const GOLD = '\x1b[38;2;255;215;0m';
+const GREEN = '\x1b[38;2;16;185;129m';
+const RED = '\x1b[38;2;239;68;68m';
+
+const SESSION_ID = 'tui:local';
+const CHANNEL_ID = 'tui';
+const TUI_MULTILINE_PASTE_DEBOUNCE_MS = Math.max(
+  20,
+  parseInt(process.env.TUI_MULTILINE_PASTE_DEBOUNCE_MS || '90', 10) || 90,
+);
+
+let activeRunAbortController: AbortController | null = null;
+
+function printBanner(): void {
+  const T = TEAL;
+  const N = NAVY;
+  const logo = [
+    `${T}                            ####  ####${RESET}`,
+    `${T}                       #########  #########${RESET}`,
+    `${T}                    ####       #  #${N}      #####${RESET}`,
+    `${T}                  ###          #  #${N}         ####${RESET}`,
+    `${T}                ##             #  #${N}            ###${RESET}`,
+    `${T}               ##       ##     #  #${N}    #        ###${RESET}`,
+    `${T}  #######     ##       #####   #  #${N}   ####        ##${RESET}`,
+    `${T}##### #####  ##         ###  ###  #${N}#    #          ##   ${N}######${RESET}`,
+    `${T}## ##### ##  #                     ${N}##              ##   ##  ##${RESET}`,
+    `${T} ###    ###  ##             #       ${N}#              ##    ####${RESET}`,
+    `${T}       #      ##            ###    ${N}##            ####     ##${RESET}`,
+    `${T}     ##           #           ##  ${N}##         ####  ##     ##${RESET}`,
+    `${T} ####    ##        #               ${N}#  #       ####    ##      ##     ${N}###${RESET}`,
+    `${T} ####    ####       ##             ${N}#  #    ###     ###        ##    ${N}####${RESET}`,
+    `${T}            ####       ####   #    ${N}#  #  ###########         ##${RESET}`,
+    `${T}######      ###    ##            ##${N}     #####        ####   ###        ${N}#####${RESET}`,
+    `${T}          ##     ##           #    ${N}         ###       ###    ###${RESET}`,
+    `${T}          ##     #              ###${N}######     ##        #    ##${RESET}`,
+    `${T}          ##    #         #        ${N}   #######  ##       ##   ##${RESET}`,
+    `${T}          ##    #           # ##   ${N}     ######  #       ##   ##${RESET}`,
+    `${T}          ##    #          #####${N}######    ####  #       ##${RESET}`,
+    `${T}                 #              ${N}       ###   ##  #       #    # #${RESET}`,
+    `${T}       # ### #   #       #  ###${N}         ###    ##     ###   ######${RESET}`,
+    `${T}       # ###      ##          #${N}#########     ##      ##     ######${RESET}`,
+    `${T}                    #       #  ${N}            ###     ###${RESET}`,
+    `${T}              ####   ###     ##${N}#####  ######     ###    ${N}####${RESET}`,
+    `${T}                        ###   ${N}     # ##      #####${RESET}`,
+    `${T}                           ###${N}### # ##########${RESET}`,
+    `${T}                              ${N}  ##  ###${RESET}`,
+  ];
+  console.log();
+  for (const line of logo) console.log(line);
+  console.log();
+  console.log(`  \u{1F99E} ${BOLD}${TEAL}H y b r i d ${GOLD}C l a w${RESET} ${DIM}v${APP_VERSION}${RESET}`);
+  console.log(`${DIM}     Powered by HybridAI${RESET}`);
+  console.log();
+  console.log(`  ${DIM}Model: ${TEAL}${HYBRIDAI_MODEL}${RESET}${DIM} | Bot: ${GOLD}${HYBRIDAI_CHATBOT_ID || 'unset'}${RESET}`);
+  console.log(`  ${DIM}Gateway: ${TEAL}${GATEWAY_BASE_URL}${RESET}`);
+  console.log(`  ${DIM}HybridAI: ${TEAL}${HYBRIDAI_BASE_URL}${RESET}`);
+  console.log();
+}
+
+function printHelp(): void {
+  console.log();
+  console.log(`  ${BOLD}${GOLD}Commands${RESET}`);
+  console.log(`  ${TEAL}/help${RESET}             Show this help`);
+  console.log(`  ${TEAL}/bots${RESET}             List available bots`);
+  console.log(`  ${TEAL}/bot <id|name>${RESET}    Switch bot for this session`);
+  console.log(`  ${TEAL}/rag [on|off]${RESET}     Toggle or set RAG`);
+  console.log(`  ${TEAL}/info${RESET}             Show current settings`);
+  console.log(`  ${TEAL}/clear${RESET}            Clear session history`);
+  console.log(`  ${TEAL}/stop${RESET}             Interrupt current request`);
+  console.log(`  ${TEAL}/exit${RESET}             Quit`);
+  console.log(`  ${TEAL}ESC${RESET}               Interrupt current request`);
+  console.log();
+}
+
+function printResponse(text: string): void {
+  console.log();
+  for (const line of text.split('\n')) {
+    console.log(`  ${line}`);
+  }
+  console.log();
+}
+
+function printError(text: string): void {
+  console.log(`\n${RED}  Error: ${text}${RESET}\n`);
+}
+
+function printInfo(text: string): void {
+  console.log(`\n${GOLD}  ${text}${RESET}\n`);
+}
+
+function printToolUsage(tools: string[]): void {
+  if (tools.length === 0) return;
+  console.log(`${DIM}  tools: ${GREEN}${tools.join(', ')}${RESET}`);
+}
+
+function printGatewayCommandResult(result: GatewayCommandResult): void {
+  if (result.kind === 'error') {
+    const prefix = result.title ? `${result.title}: ` : '';
+    printError(`${prefix}${result.text}`);
+    return;
+  }
+  printInfo(renderGatewayCommand(result));
+}
+
+function spinner(): { stop: () => void } {
+  const dots = ['   ', '.  ', '.. ', '...'];
+  let i = 0;
+  const clearLine = () => process.stdout.write('\r\x1b[2K');
+  const render = () => {
+    clearLine();
+    process.stdout.write(`\r  ${TEAL}thinking${dots[i % dots.length]}${RESET}`);
+    i++;
+  };
+  const interval = setInterval(render, 350);
+  render();
+  return {
+    stop: () => {
+      clearInterval(interval);
+      clearLine();
+    },
+  };
+}
+
+async function runGatewayCommand(args: string[]): Promise<void> {
+  try {
+    const result = await gatewayCommand({
+      sessionId: SESSION_ID,
+      guildId: null,
+      channelId: CHANNEL_ID,
+      args,
+    });
+    printGatewayCommandResult(result);
+  } catch (err) {
+    printError(err instanceof Error ? err.message : String(err));
+  }
+}
+
+async function handleSlashCommand(input: string, rl: readline.Interface): Promise<boolean> {
+  const parts = input.slice(1).trim().split(/\s+/).filter(Boolean);
+  const cmd = (parts[0] || '').toLowerCase();
+
+  switch (cmd) {
+    case 'help':
+      printHelp();
+      return true;
+    case 'exit':
+    case 'quit':
+    case 'q':
+      console.log(`\n  ${GOLD}Goodbye!${RESET}\n`);
+      rl.close();
+      process.exit(0);
+    case 'bots':
+      await runGatewayCommand(['bot', 'list']);
+      return true;
+    case 'bot':
+      if (parts.length > 1) {
+        await runGatewayCommand(['bot', 'set', ...parts.slice(1)]);
+      } else {
+        await runGatewayCommand(['bot', 'info']);
+      }
+      return true;
+    case 'rag':
+      if (parts.length > 1 && (parts[1] === 'on' || parts[1] === 'off')) {
+        await runGatewayCommand(['rag', parts[1]]);
+      } else {
+        await runGatewayCommand(['rag']);
+      }
+      return true;
+    case 'info':
+      await runGatewayCommand(['bot', 'info']);
+      await runGatewayCommand(['model', 'info']);
+      await runGatewayCommand(['status']);
+      return true;
+    case 'clear':
+      await runGatewayCommand(['clear']);
+      return true;
+    case 'stop':
+    case 'abort':
+      if (activeRunAbortController && !activeRunAbortController.signal.aborted) {
+        activeRunAbortController.abort();
+        printInfo('Stopping current request...');
+      } else {
+        printInfo('No active request.');
+      }
+      return true;
+    default:
+      return false;
+  }
+}
+
+async function processMessage(content: string): Promise<void> {
+  const s = spinner();
+  const abortController = new AbortController();
+  activeRunAbortController = abortController;
+
+  try {
+    const result = await gatewayChat(
+      {
+        sessionId: SESSION_ID,
+        guildId: null,
+        channelId: CHANNEL_ID,
+        userId: 'tui-user',
+        username: 'user',
+        content,
+      },
+      abortController.signal,
+    );
+    s.stop();
+
+    if (result.status === 'error') {
+      if ((result.error || '').includes('aborted') || (result.error || '').includes('Interrupted')) return;
+      printError(result.error || 'Unknown error');
+      return;
+    }
+
+    printToolUsage(result.toolsUsed);
+    printResponse(result.result || 'No response.');
+  } catch (err) {
+    s.stop();
+    if (abortController.signal.aborted) return;
+    printError(err instanceof Error ? err.message : String(err));
+  } finally {
+    if (activeRunAbortController === abortController) {
+      activeRunAbortController = null;
+    }
+  }
+}
+
+async function main(): Promise<void> {
+  logger.level = 'warn';
+  await gatewayStatus();
+  printBanner();
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: `${TEAL}>${RESET} `,
+    historySize: 100,
+  });
+
+  readline.emitKeypressEvents(process.stdin, rl);
+  if (process.stdin.isTTY) process.stdin.setRawMode(true);
+  process.stdin.on('keypress', (_str, key) => {
+    if (key?.name !== 'escape') return;
+    if (!activeRunAbortController || activeRunAbortController.signal.aborted) return;
+    activeRunAbortController.abort();
+  });
+
+  rl.prompt();
+  let pendingInputLines: string[] = [];
+  let pendingInputTimer: ReturnType<typeof setTimeout> | null = null;
+  let inputRunQueue = Promise.resolve();
+
+  const enqueueInput = (input: string): void => {
+    inputRunQueue = inputRunQueue
+      .then(async () => {
+        const trimmed = input.trim();
+        if (!trimmed) {
+          rl.prompt();
+          return;
+        }
+        if (!input.includes('\n') && trimmed.startsWith('/')) {
+          const handled = await handleSlashCommand(trimmed, rl);
+          if (handled) {
+            rl.prompt();
+            return;
+          }
+        }
+        await processMessage(input);
+        rl.prompt();
+      })
+      .catch((err) => {
+        printError(err instanceof Error ? err.message : String(err));
+        rl.prompt();
+      });
+  };
+
+  const flushPendingInput = (): void => {
+    if (pendingInputTimer) {
+      clearTimeout(pendingInputTimer);
+      pendingInputTimer = null;
+    }
+    if (pendingInputLines.length === 0) return;
+    const combined = pendingInputLines.join('\n');
+    pendingInputLines = [];
+    enqueueInput(combined);
+  };
+
+  rl.on('line', (line) => {
+    pendingInputLines.push(line);
+    if (pendingInputTimer) clearTimeout(pendingInputTimer);
+    pendingInputTimer = setTimeout(flushPendingInput, TUI_MULTILINE_PASTE_DEBOUNCE_MS);
+  });
+
+  rl.on('close', () => {
+    if (pendingInputTimer) clearTimeout(pendingInputTimer);
+    if (process.stdin.isTTY) process.stdin.setRawMode(false);
+    console.log(`\n${DIM}  Goodbye!${RESET}\n`);
+    process.exit(0);
+  });
+}
+
+main().catch((err) => {
+  console.error('TUI error:', err);
+  process.exit(1);
+});

package/src/types.ts

@@ -0,0 +1,135 @@
+// --- HybridAI API types ---
+
+export interface ChatMessage {
+  role: 'system' | 'user' | 'assistant' | 'tool';
+  content: string | null;
+  tool_calls?: ToolCall[];
+  tool_call_id?: string;
+}
+
+export interface ToolCall {
+  id: string;
+  type: 'function';
+  function: {
+    name: string;
+    arguments: string;
+  };
+}
+
+export interface HybridAIBot {
+  id: string;
+  name: string;
+  description?: string;
+}
+
+// --- Container IPC types ---
+
+export interface ContainerInput {
+  sessionId: string;
+  messages: ChatMessage[];
+  chatbotId: string;
+  enableRag: boolean;
+  apiKey: string;
+  baseUrl: string;
+  model: string;
+  channelId: string;
+  scheduledTasks?: { id: number; cronExpr: string; runAt: string | null; everyMs: number | null; prompt: string; enabled: number; lastRun: string | null; createdAt: string }[];
+  allowedTools?: string[];
+}
+
+export interface ToolExecution {
+  name: string;
+  arguments: string;
+  result: string;
+  durationMs: number;
+}
+
+export interface ToolProgressEvent {
+  sessionId: string;
+  toolName: string;
+  phase: 'start' | 'finish';
+  preview?: string;
+  durationMs?: number;
+}
+
+export interface ContainerOutput {
+  status: 'success' | 'error';
+  result: string | null;
+  toolsUsed: string[];
+  toolExecutions?: ToolExecution[];
+  error?: string;
+  sideEffects?: { schedules?: ScheduleSideEffect[] };
+}
+
+export type ScheduleSideEffect =
+  | { action: 'add'; cronExpr?: string; runAt?: string; everyMs?: number; prompt: string }
+  | { action: 'remove'; taskId: number };
+
+// --- Database types ---
+
+export interface Session {
+  id: string;
+  guild_id: string | null;
+  channel_id: string;
+  chatbot_id: string | null;
+  model: string | null;
+  enable_rag: number;
+  message_count: number;
+  session_summary: string | null;
+  summary_updated_at: string | null;
+  compaction_count: number;
+  memory_flush_at: string | null;
+  created_at: string;
+  last_active: string;
+}
+
+export interface StoredMessage {
+  id: number;
+  session_id: string;
+  user_id: string;
+  username: string | null;
+  role: string;
+  content: string;
+  created_at: string;
+}
+
+export interface ScheduledTask {
+  id: number;
+  session_id: string;
+  channel_id: string;
+  cron_expr: string;
+  run_at: string | null;
+  every_ms: number | null;
+  prompt: string;
+  enabled: number;
+  last_run: string | null;
+  created_at: string;
+}
+
+export interface AuditEntry {
+  id: number;
+  session_id: string | null;
+  event: string;
+  detail: string | null;
+  duration_ms: number | null;
+  created_at: string;
+}
+
+// --- Mount security types ---
+
+export interface AdditionalMount {
+  hostPath: string;
+  containerPath?: string;
+  readonly?: boolean; // Default: true
+}
+
+export interface MountAllowlist {
+  allowedRoots: AllowedRoot[];
+  blockedPatterns: string[];
+}
+
+export interface AllowedRoot {
+  path: string;
+  allowReadWrite: boolean;
+  description?: string;
+}

package/src/workspace.ts

@@ -0,0 +1,171 @@
+/**
+ * Workspace bootstrap files — loads SOUL.md, IDENTITY.md, USER.md,
+ * TOOLS.md, MEMORY.md, HEARTBEAT.md from the agent workspace
+ * and injects them into the system prompt (like OpenClaw).
+ */
+import fs from 'fs';
+import path from 'path';
+
+import { logger } from './logger.js';
+import { agentWorkspaceDir } from './ipc.js';
+
+const BOOTSTRAP_FILES = [
+  'AGENTS.md',
+  'SOUL.md',
+  'IDENTITY.md',
+  'USER.md',
+  'TOOLS.md',
+  'MEMORY.md',
+  'HEARTBEAT.md',
+  'BOOTSTRAP.md',
+  'BOOT.md',
+] as const;
+
+const MAX_FILE_CHARS = 20_000;
+const TEMPLATES_DIR = path.join(process.cwd(), 'templates');
+
+export interface ContextFile {
+  name: string;
+  content: string;
+}
+
+/**
+ * Ensure workspace has bootstrap files, copying from templates if missing.
+ */
+export function ensureBootstrapFiles(agentId: string): void {
+  const wsDir = agentWorkspaceDir(agentId);
+  fs.mkdirSync(wsDir, { recursive: true });
+
+  for (const filename of BOOTSTRAP_FILES) {
+    const destPath = path.join(wsDir, filename);
+    if (fs.existsSync(destPath)) continue;
+
+    const templatePath = path.join(TEMPLATES_DIR, filename);
+    if (fs.existsSync(templatePath)) {
+      fs.copyFileSync(templatePath, destPath);
+      logger.debug({ agentId, file: filename }, 'Copied bootstrap template');
+    }
+  }
+}
+
+/**
+ * Load all bootstrap files from the workspace.
+ * Returns only files that exist and have content.
+ */
+export function loadBootstrapFiles(agentId: string): ContextFile[] {
+  const wsDir = agentWorkspaceDir(agentId);
+  const files: ContextFile[] = [];
+
+  for (const filename of BOOTSTRAP_FILES) {
+    const filePath = path.join(wsDir, filename);
+    if (!fs.existsSync(filePath)) continue;
+
+    try {
+      let content = fs.readFileSync(filePath, 'utf-8').trim();
+      if (!content) continue;
+
+      if (content.length > MAX_FILE_CHARS) {
+        content = content.slice(0, MAX_FILE_CHARS) + '\n\n[truncated]';
+      }
+
+      files.push({ name: filename, content });
+    } catch (err) {
+      logger.warn({ agentId, file: filename, err }, 'Failed to read bootstrap file');
+    }
+  }
+
+  return files;
+}
+
+/**
+ * Format the current date/time in a human-friendly way, like OpenClaw.
+ * e.g. "Tuesday, February 24th, 2026 — 14:32"
+ */
+function formatCurrentTime(timezone?: string): string {
+  const tz = timezone?.trim() || Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC';
+  const now = new Date();
+  try {
+    const parts = new Intl.DateTimeFormat('en-US', {
+      timeZone: tz,
+      weekday: 'long',
+      year: 'numeric',
+      month: 'long',
+      day: 'numeric',
+      hour: '2-digit',
+      minute: '2-digit',
+      hourCycle: 'h23',
+    }).formatToParts(now);
+    const map: Record<string, string> = {};
+    for (const part of parts) {
+      if (part.type !== 'literal') map[part.type] = part.value;
+    }
+    if (!map.weekday || !map.year || !map.month || !map.day || !map.hour || !map.minute) {
+      return now.toISOString();
+    }
+    const dayNum = parseInt(map.day, 10);
+    const suffix = dayNum >= 11 && dayNum <= 13 ? 'th'
+      : dayNum % 10 === 1 ? 'st'
+      : dayNum % 10 === 2 ? 'nd'
+      : dayNum % 10 === 3 ? 'rd' : 'th';
+    return `${map.weekday}, ${map.month} ${dayNum}${suffix}, ${map.year} — ${map.hour}:${map.minute} (${tz})`;
+  } catch {
+    return now.toISOString();
+  }
+}
+
+/**
+ * Build a system prompt section from loaded context files.
+ * Injects current date/time (like OpenClaw) so the agent knows when "now" is.
+ */
+export function buildContextPrompt(files: ContextFile[]): string {
+  if (files.length === 0) return '';
+
+  // Extract timezone from USER.md if available
+  const userFile = files.find((f) => f.name === 'USER.md');
+  const tzMatch = userFile?.content.match(/\*\*Timezone:\*\*\s*(.+)/i);
+  const userTimezone = tzMatch?.[1]?.trim() || undefined;
+
+  const lines: string[] = [
+    '# Project Context',
+    '',
+    'The following workspace context files have been loaded.',
+    'If SOUL.md is present, embody its persona and tone.',
+    '',
+    '## Current Date & Time',
+    formatCurrentTime(userTimezone),
+    '',
+  ];
+
+  for (const file of files) {
+    lines.push(`## ${file.name}`, '', file.content, '');
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Check if the workspace still needs bootstrapping.
+ * Like OpenClaw: if the agent deleted BOOTSTRAP.md, or if IDENTITY.md / USER.md
+ * have been modified from templates, bootstrapping is considered complete.
+ */
+export function isBootstrapping(agentId: string): boolean {
+  const wsDir = agentWorkspaceDir(agentId);
+  if (!fs.existsSync(path.join(wsDir, 'BOOTSTRAP.md'))) return false;
+
+  // Fallback: if the agent already filled in IDENTITY.md or USER.md, it's done
+  for (const filename of ['IDENTITY.md', 'USER.md']) {
+    const wsFile = path.join(wsDir, filename);
+    const tmplFile = path.join(TEMPLATES_DIR, filename);
+    if (!fs.existsSync(wsFile) || !fs.existsSync(tmplFile)) continue;
+    const wsContent = fs.readFileSync(wsFile, 'utf-8');
+    const tmplContent = fs.readFileSync(tmplFile, 'utf-8');
+    if (wsContent !== tmplContent) {
+      // Agent modified workspace files — bootstrapping is effectively done, clean up
+      fs.unlinkSync(path.join(wsDir, 'BOOTSTRAP.md'));
+      return false;
+    }
+  }
+
+  return true;
+}
+