@hybridaione/hybridclaw 0.2.2 → 0.2.6

package/src/tui.ts

@@ -2,17 +2,23 @@
  * HybridClaw TUI — thin client for the gateway API.
  * Usage: npm run tui
  */
-import readline from 'readline';
+import readline from 'node:readline';
 
-import { APP_VERSION, GATEWAY_BASE_URL, HYBRIDAI_BASE_URL, HYBRIDAI_CHATBOT_ID, HYBRIDAI_MODEL } from './config.js';
 import {
+  APP_VERSION,
+  GATEWAY_BASE_URL,
+  HYBRIDAI_BASE_URL,
+  HYBRIDAI_CHATBOT_ID,
+  HYBRIDAI_MODEL,
+} from './config.js';
+import {
+  type GatewayChatResult,
+  type GatewayCommandResult,
+  gatewayChat,
   gatewayChatStream,
   gatewayCommand,
-  gatewayChat,
   gatewayStatus,
   renderGatewayCommand,
-  type GatewayChatResult,
-  type GatewayCommandResult,
 } from './gateway-client.js';
 import { logger } from './logger.js';
 
@@ -53,7 +59,10 @@ function inferThemeFromColorFgBg(): TuiTheme | null {
   const raw = process.env.COLORFGBG;
   if (!raw) return null;
 
-  const parts = raw.split(/[;:]/).map((part) => part.trim()).filter(Boolean);
+  const parts = raw
+    .split(/[;:]/)
+    .map((part) => part.trim())
+    .filter(Boolean);
   if (parts.length === 0) return null;
 
   const bg = Number.parseInt(parts[parts.length - 1], 10);
@@ -64,7 +73,14 @@ function inferThemeFromColorFgBg(): TuiTheme | null {
 }
 
 function resolveTuiTheme(): TuiTheme {
-  const override = (process.env.HYBRIDCLAW_THEME || process.env.HYBRIDCLAW_TUI_THEME || process.env.TUI_THEME || '').trim().toLowerCase();
+  const override = (
+    process.env.HYBRIDCLAW_THEME ||
+    process.env.HYBRIDCLAW_TUI_THEME ||
+    process.env.TUI_THEME ||
+    ''
+  )
+    .trim()
+    .toLowerCase();
   if (override === 'light' || override === 'dark') return override;
   return inferThemeFromColorFgBg() || 'dark';
 }
@@ -87,6 +103,84 @@ const TOOL_PREVIEW_MAX_CHARS = 140;
 
 let activeRunAbortController: AbortController | null = null;
 
+function findPendingApprovalRequestId(
+  result: GatewayChatResult,
+): string | null {
+  const executions = result.toolExecutions || [];
+  for (let i = executions.length - 1; i >= 0; i -= 1) {
+    const execution = executions[i];
+    if (execution.approvalDecision !== 'required') continue;
+    if (!execution.approvalRequestId) continue;
+    return execution.approvalRequestId;
+  }
+  return null;
+}
+
+function mapApprovalSelectionToCommand(
+  selection: string,
+  requestId: string,
+): string | null {
+  const normalized = selection.trim().toLowerCase().replace(/\s+/g, ' ');
+  if (!normalized) return null;
+
+  if (
+    normalized === '1' ||
+    normalized === 'yes' ||
+    normalized === 'y' ||
+    normalized === 'once'
+  ) {
+    return `yes ${requestId}`;
+  }
+  if (
+    normalized === '2' ||
+    normalized === 'session' ||
+    normalized === 'yes for session' ||
+    normalized === 'for session'
+  ) {
+    return `yes ${requestId} for session`;
+  }
+  if (
+    normalized === '3' ||
+    normalized === 'agent' ||
+    normalized === 'yes for agent' ||
+    normalized === 'for agent'
+  ) {
+    return `yes ${requestId} for agent`;
+  }
+  if (
+    normalized === '4' ||
+    normalized === 'no' ||
+    normalized === 'n' ||
+    normalized === 'skip'
+  ) {
+    return `skip ${requestId}`;
+  }
+  return null;
+}
+
+async function promptApprovalSelection(
+  rl: readline.Interface,
+  requestId: string,
+): Promise<string | null> {
+  console.log(
+    `  ${BOLD}${GOLD}Approval options${RESET} ${MUTED}(request ${requestId})${RESET}`,
+  );
+  console.log(`  ${TEAL}1${RESET} yes (once)`);
+  console.log(`  ${TEAL}2${RESET} yes for session`);
+  console.log(`  ${TEAL}3${RESET} yes for agent`);
+  console.log(`  ${TEAL}4${RESET} no / skip`);
+  const answer = await new Promise<string>((resolve) => {
+    rl.question(`  ${MUTED}Select 1-4 (Enter to skip):${RESET} `, resolve);
+  });
+  const command = mapApprovalSelectionToCommand(answer, requestId);
+  if (answer.trim() && !command) {
+    printInfo(
+      `Unrecognized selection "${answer.trim()}". You can reply manually with yes/skip and the request id.`,
+    );
+  }
+  return command;
+}
+
 function printBanner(): void {
   const T = TEAL;
   const N = NAVY;
@@ -124,12 +218,18 @@ function printBanner(): void {
   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} ${MUTED}v${APP_VERSION}${RESET}`);
+  console.log(
+    `  \u{1F99E} ${BOLD}${TEAL}H y b r i d ${GOLD}C l a w${RESET} ${MUTED}v${APP_VERSION}${RESET}`,
+  );
   console.log(`${MUTED}     Powered by HybridAI${RESET}`);
   console.log();
-  console.log(`  ${MUTED}Model:${RESET} ${TEAL}${HYBRIDAI_MODEL}${RESET}${MUTED} | Bot:${RESET} ${GOLD}${HYBRIDAI_CHATBOT_ID || 'unset'}${RESET}`);
+  console.log(
+    `  ${MUTED}Model:${RESET} ${TEAL}${HYBRIDAI_MODEL}${RESET}${MUTED} | Bot:${RESET} ${GOLD}${HYBRIDAI_CHATBOT_ID || 'unset'}${RESET}`,
+  );
   console.log(`  ${MUTED}Gateway:${RESET} ${TEAL}${GATEWAY_BASE_URL}${RESET}`);
-  console.log(`  ${MUTED}HybridAI:${RESET} ${TEAL}${HYBRIDAI_BASE_URL}${RESET}`);
+  console.log(
+    `  ${MUTED}HybridAI:${RESET} ${TEAL}${HYBRIDAI_BASE_URL}${RESET}`,
+  );
   console.log();
 }
 
@@ -162,12 +262,18 @@ function printError(text: string): void {
 }
 
 function printInfo(text: string): void {
-  console.log(`\n  ${GOLD}${text}${RESET}\n`);
+  console.log();
+  for (const line of text.split('\n')) {
+    console.log(`  ${GOLD}${line}${RESET}`);
+  }
+  console.log();
 }
 
 function printToolUsage(tools: string[]): void {
   if (tools.length === 0) return;
-  console.log(`  ${MUTED}${JELLYFISH} tools:${RESET} ${GREEN}${tools.join(', ')}${RESET}`);
+  console.log(
+    `  ${MUTED}${JELLYFISH} tools:${RESET} ${GREEN}${tools.join(', ')}${RESET}`,
+  );
 }
 
 function printGatewayCommandResult(result: GatewayCommandResult): void {
@@ -190,7 +296,7 @@ function spinner(): {
   const clearLine = () => process.stdout.write('\r\x1b[2K');
   const render = () => {
     clearLine();
-      process.stdout.write(`\r${TEAL}thinking${dots[i % dots.length]}${RESET}`);
+    process.stdout.write(`\r${TEAL}thinking${dots[i % dots.length]}${RESET}`);
     i++;
   };
   const interval = setInterval(render, 350);
@@ -203,7 +309,9 @@ function spinner(): {
     addTool: (toolName: string, preview?: string) => {
       clearLine();
       const previewText = preview ? ` ${MUTED}${preview}${RESET}` : '';
-      process.stdout.write(`  ${JELLYFISH} ${TEAL}${toolName}${RESET}${previewText}\n`);
+      process.stdout.write(
+        `  ${JELLYFISH} ${TEAL}${toolName}${RESET}${previewText}\n`,
+      );
       transientToolLines++;
       render();
     },
@@ -234,7 +342,10 @@ async function runGatewayCommand(args: string[]): Promise<void> {
   }
 }
 
-async function handleSlashCommand(input: string, rl: readline.Interface): Promise<boolean> {
+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();
 
@@ -248,6 +359,7 @@ async function handleSlashCommand(input: string, rl: readline.Interface): Promis
       console.log(`\n  ${GOLD}Goodbye!${RESET}\n`);
       rl.close();
       process.exit(0);
+      return true;
     case 'bots':
       await runGatewayCommand(['bot', 'list']);
       return true;
@@ -282,7 +394,10 @@ async function handleSlashCommand(input: string, rl: readline.Interface): Promis
       return true;
     case 'stop':
     case 'abort':
-      if (activeRunAbortController && !activeRunAbortController.signal.aborted) {
+      if (
+        activeRunAbortController &&
+        !activeRunAbortController.signal.aborted
+      ) {
         activeRunAbortController.abort();
         printInfo('Stopping current request...');
       } else {
@@ -294,7 +409,10 @@ async function handleSlashCommand(input: string, rl: readline.Interface): Promis
   }
 }
 
-async function processMessage(content: string): Promise<void> {
+async function processMessage(
+  content: string,
+  rl: readline.Interface,
+): Promise<void> {
   const s = spinner();
   const abortController = new AbortController();
   activeRunAbortController = abortController;
@@ -325,11 +443,17 @@ async function processMessage(content: string): Promise<void> {
           stream: true,
         },
         (event) => {
-          if (event.type !== 'tool' || event.phase !== 'start' || !event.toolName) return;
+          if (
+            event.type !== 'tool' ||
+            event.phase !== 'start' ||
+            !event.toolName
+          )
+            return;
           const preview = (event.preview || '').replace(/\s+/g, ' ').trim();
-          const previewText = preview.length > TOOL_PREVIEW_MAX_CHARS
-            ? `${preview.slice(0, TOOL_PREVIEW_MAX_CHARS - 1)}…`
-            : preview;
+          const previewText =
+            preview.length > TOOL_PREVIEW_MAX_CHARS
+              ? `${preview.slice(0, TOOL_PREVIEW_MAX_CHARS - 1)}…`
+              : preview;
           toolNames.add(event.toolName);
           s.addTool(event.toolName, previewText || undefined);
         },
@@ -361,7 +485,10 @@ async function processMessage(content: string): Promise<void> {
       printToolUsage(Array.from(toolNames));
     }
 
-    if ((result.error || '').includes('aborted') || (result.error || '').includes('Interrupted')) {
+    if (
+      (result.error || '').includes('aborted') ||
+      (result.error || '').includes('Interrupted')
+    ) {
       return;
     }
 
@@ -371,6 +498,16 @@ async function processMessage(content: string): Promise<void> {
     }
 
     printResponse(result.result || 'No response.');
+    const pendingApprovalId = findPendingApprovalRequestId(result);
+    if (pendingApprovalId) {
+      const approvalCommand = await promptApprovalSelection(
+        rl,
+        pendingApprovalId,
+      );
+      if (approvalCommand) {
+        await processMessage(approvalCommand, rl);
+      }
+    }
   } catch (err) {
     s.stop();
     if (abortController.signal.aborted) return;
@@ -399,7 +536,8 @@ async function main(): Promise<void> {
   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;
+    if (!activeRunAbortController || activeRunAbortController.signal.aborted)
+      return;
     activeRunAbortController.abort();
   });
 
@@ -423,7 +561,7 @@ async function main(): Promise<void> {
             return;
           }
         }
-        await processMessage(input);
+        await processMessage(input, rl);
         rl.prompt();
       })
       .catch((err) => {
@@ -446,7 +584,10 @@ async function main(): Promise<void> {
   rl.on('line', (line) => {
     pendingInputLines.push(line);
     if (pendingInputTimer) clearTimeout(pendingInputTimer);
-    pendingInputTimer = setTimeout(flushPendingInput, TUI_MULTILINE_PASTE_DEBOUNCE_MS);
+    pendingInputTimer = setTimeout(
+      flushPendingInput,
+      TUI_MULTILINE_PASTE_DEBOUNCE_MS,
+    );
   });
 
   rl.on('close', () => {

package/src/types.ts

@@ -59,7 +59,16 @@ export interface ContainerInput {
   gatewayApiToken?: 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 }[];
+  scheduledTasks?: {
+    id: number;
+    cronExpr: string;
+    runAt: string | null;
+    everyMs: number | null;
+    prompt: string;
+    enabled: number;
+    lastRun: string | null;
+    createdAt: string;
+  }[];
   allowedTools?: string[];
   blockedTools?: string[];
   media?: MediaContextItem[];
@@ -73,6 +82,20 @@ export interface ToolExecution {
   isError?: boolean;
   blocked?: boolean;
   blockedReason?: string;
+  approvalTier?: 'green' | 'yellow' | 'red';
+  approvalBaseTier?: 'green' | 'yellow' | 'red';
+  approvalDecision?:
+    | 'auto'
+    | 'implicit'
+    | 'approved_once'
+    | 'approved_session'
+    | 'approved_agent'
+    | 'promoted'
+    | 'required'
+    | 'denied';
+  approvalActionKey?: string;
+  approvalReason?: string;
+  approvalRequestId?: string;
 }
 
 export interface ToolProgressEvent {
@@ -108,6 +131,7 @@ export interface ContainerOutput {
   toolExecutions?: ToolExecution[];
   tokenUsage?: TokenUsageStats;
   error?: string;
+  effectiveUserPrompt?: string;
   sideEffects?: {
     schedules?: ScheduleSideEffect[];
     delegations?: DelegationSideEffect[];
@@ -115,7 +139,13 @@ export interface ContainerOutput {
 }
 
 export type ScheduleSideEffect =
-  | { action: 'add'; cronExpr?: string; runAt?: string; everyMs?: number; prompt: string }
+  | {
+      action: 'add';
+      cronExpr?: string;
+      runAt?: string;
+      everyMs?: number;
+      prompt: string;
+    }
   | { action: 'remove'; taskId: number };
 
 export interface DelegationTaskSpec {
@@ -162,6 +192,167 @@ export interface StoredMessage {
   created_at: string;
 }
 
+export interface SemanticMemoryEntry {
+  id: number;
+  session_id: string;
+  role: string;
+  source: string;
+  scope: string;
+  metadata: Record<string, unknown>;
+  content: string;
+  confidence: number;
+  embedding: number[] | null;
+  source_message_id: number | null;
+  created_at: string;
+  accessed_at: string;
+  access_count: number;
+}
+
+export interface StructuredMemoryEntry {
+  agent_id: string;
+  key: string;
+  value: unknown;
+  version: number;
+  updated_at: string;
+}
+
+export enum KnowledgeEntityType {
+  Person = 'person',
+  Organization = 'organization',
+  Project = 'project',
+  Concept = 'concept',
+  Event = 'event',
+  Location = 'location',
+  Document = 'document',
+  Tool = 'tool',
+}
+
+export interface KnowledgeEntityCustomType {
+  custom: string;
+}
+
+export type KnowledgeEntityTypeValue =
+  | KnowledgeEntityType
+  | KnowledgeEntityCustomType;
+
+export enum KnowledgeRelationType {
+  WorksAt = 'works_at',
+  KnowsAbout = 'knows_about',
+  RelatedTo = 'related_to',
+  DependsOn = 'depends_on',
+  OwnedBy = 'owned_by',
+  CreatedBy = 'created_by',
+  LocatedIn = 'located_in',
+  PartOf = 'part_of',
+  Uses = 'uses',
+  Produces = 'produces',
+}
+
+export interface KnowledgeRelationCustomType {
+  custom: string;
+}
+
+export type KnowledgeRelationTypeValue =
+  | KnowledgeRelationType
+  | KnowledgeRelationCustomType;
+
+export interface KnowledgeEntity {
+  id: string;
+  entity_type: KnowledgeEntityTypeValue;
+  name: string;
+  properties: Record<string, unknown>;
+  created_at: string;
+  updated_at: string;
+}
+
+export interface KnowledgeRelation {
+  source: string;
+  relation: KnowledgeRelationTypeValue;
+  target: string;
+  properties: Record<string, unknown>;
+  confidence: number;
+  created_at: string;
+}
+
+export interface KnowledgeGraphPattern {
+  source?: string;
+  relation?: KnowledgeRelationTypeValue;
+  target?: string;
+  max_depth?: number;
+}
+
+export interface KnowledgeGraphMatch {
+  source: KnowledgeEntity;
+  relation: KnowledgeRelation;
+  target: KnowledgeEntity;
+}
+
+export interface CanonicalSessionMessage {
+  role: string;
+  content: string;
+  session_id: string;
+  channel_id: string | null;
+  created_at: string;
+}
+
+export interface CanonicalSession {
+  canonical_id: string;
+  agent_id: string;
+  user_id: string;
+  messages: CanonicalSessionMessage[];
+  compaction_cursor: number;
+  compacted_summary: string | null;
+  message_count: number;
+  created_at: string;
+  updated_at: string;
+}
+
+export interface CanonicalSessionContext {
+  summary: string | null;
+  recent_messages: CanonicalSessionMessage[];
+}
+
+export type UsageWindow = 'daily' | 'monthly' | 'all';
+
+export interface UsageTotals {
+  total_input_tokens: number;
+  total_output_tokens: number;
+  total_tokens: number;
+  total_cost_usd: number;
+  call_count: number;
+  total_tool_calls: number;
+}
+
+export interface UsageModelAggregate {
+  model: string;
+  total_input_tokens: number;
+  total_output_tokens: number;
+  total_tokens: number;
+  total_cost_usd: number;
+  call_count: number;
+  total_tool_calls: number;
+}
+
+export interface UsageAgentAggregate {
+  agent_id: string;
+  total_input_tokens: number;
+  total_output_tokens: number;
+  total_tokens: number;
+  total_cost_usd: number;
+  call_count: number;
+  total_tool_calls: number;
+}
+
+export interface UsageDailyAggregate {
+  day: string;
+  total_input_tokens: number;
+  total_output_tokens: number;
+  total_tokens: number;
+  total_cost_usd: number;
+  call_count: number;
+  total_tool_calls: number;
+}
+
 export interface ScheduledTask {
   id: number;
   session_id: string;
@@ -172,6 +363,8 @@ export interface ScheduledTask {
   prompt: string;
   enabled: number;
   last_run: string | null;
+  last_status: string | null;
+  consecutive_errors: number;
   created_at: string;
 }