genbox-agent 0.0.2 → 1.0.1

package/src/daemon.ts

@@ -1,329 +0,0 @@
-#!/usr/bin/env node
-/**
- * Genbox Agent Daemon
- *
- * WebSocket client that runs on each genbox VM and:
- * 1. Connects to the backend monitoring service
- * 2. Receives remote commands (send_prompt, send_keystroke, create_session)
- * 3. Manages tmux sessions running Claude Code
- * 4. Streams terminal output back to the dashboard
- */
-
-import { io, Socket } from 'socket.io-client';
-import { SessionManager } from './session-manager';
-
-// Configuration from environment
-const GENBOX_ID = process.env.GENBOX_ID || '';
-const GENBOX_TOKEN = process.env.GENBOX_TOKEN || '';
-const MONITORING_WS_URL = process.env.MONITORING_WS_URL || 'http://localhost:3001';
-
-// Output polling interval (ms)
-const OUTPUT_POLL_INTERVAL = 2000;
-
-interface RequestData {
-  sessionId?: string;
-  prompt?: string;
-  key?: string;
-  projectPath?: string;
-  lines?: number;
-  requestId?: string;
-}
-
-class GenboxAgentDaemon {
-  private socket: Socket | null = null;
-  private sessionManager: SessionManager;
-  private running = false;
-  private outputPollers: Map<string, NodeJS.Timeout> = new Map();
-
-  constructor(
-    private readonly genboxId: string,
-    private readonly token: string,
-    private readonly wsUrl: string,
-  ) {
-    this.sessionManager = new SessionManager(genboxId);
-  }
-
-  async connect(): Promise<boolean> {
-    return new Promise((resolve) => {
-      console.log(`Connecting to ${this.wsUrl}/claude-ws...`);
-
-      this.socket = io(`${this.wsUrl}/claude-ws`, {
-        query: { genboxId: this.genboxId, type: 'genbox' },
-        auth: { genboxId: this.genboxId, token: this.token },
-        transports: ['websocket', 'polling'],
-        reconnection: true,
-        reconnectionAttempts: Infinity,
-        reconnectionDelay: 1000,
-        reconnectionDelayMax: 30000,
-      });
-
-      this.socket.on('connect', () => {
-        console.log(`[${this.genboxId}] Connected to monitoring server`);
-        this.running = true;
-        this.onConnect();
-        resolve(true);
-      });
-
-      this.socket.on('disconnect', (reason) => {
-        console.log(`[${this.genboxId}] Disconnected: ${reason}`);
-        this.running = false;
-      });
-
-      this.socket.on('connect_error', (error) => {
-        console.error(`[${this.genboxId}] Connection error:`, error.message);
-      });
-
-      // Register event handlers
-      this.socket.on('send_prompt', this.onSendPrompt.bind(this));
-      this.socket.on('send_keystroke', this.onSendKeystroke.bind(this));
-      this.socket.on('create_session', this.onCreateSession.bind(this));
-      this.socket.on('get_output', this.onGetOutput.bind(this));
-      this.socket.on('kill_session', this.onKillSession.bind(this));
-      this.socket.on('list_sessions', this.onListSessions.bind(this));
-      this.socket.on('error', this.onError.bind(this));
-
-      // Timeout after 10 seconds
-      setTimeout(() => {
-        if (!this.socket?.connected) {
-          console.error('Connection timeout');
-          resolve(false);
-        }
-      }, 10000);
-    });
-  }
-
-  private onConnect(): void {
-    // Register as genbox agent
-    this.socket?.emit('register_agent', {
-      genboxId: this.genboxId,
-      token: this.token,
-    });
-
-    // Send initial session list
-    const sessions = this.sessionManager.listSessions();
-    this.socket?.emit('agent_sessions', {
-      genboxId: this.genboxId,
-      sessions,
-    });
-  }
-
-  private onSendPrompt(data: RequestData): void {
-    const { sessionId, prompt, requestId } = data;
-    if (!sessionId || !prompt) return;
-
-    console.log(`[${this.genboxId}] Sending prompt to ${sessionId}: ${prompt.slice(0, 50)}...`);
-
-    const success = this.sessionManager.sendPrompt(sessionId, prompt);
-
-    this.socket?.emit('prompt_result', {
-      genboxId: this.genboxId,
-      sessionId,
-      requestId,
-      success,
-    });
-
-    // Capture output after a delay
-    if (success) {
-      setTimeout(() => this.captureAndSendOutput(sessionId), 1000);
-    }
-  }
-
-  private onSendKeystroke(data: RequestData): void {
-    const { sessionId, key, requestId } = data;
-    if (!sessionId || !key) return;
-
-    console.log(`[${this.genboxId}] Sending keystroke to ${sessionId}: ${key}`);
-
-    const success = this.sessionManager.sendKeystroke(sessionId, key);
-
-    this.socket?.emit('keystroke_result', {
-      genboxId: this.genboxId,
-      sessionId,
-      requestId,
-      success,
-    });
-  }
-
-  private onCreateSession(data: RequestData): void {
-    const { projectPath = '/home/dev', requestId } = data;
-
-    console.log(`[${this.genboxId}] Creating new session at ${projectPath}`);
-
-    const session = this.sessionManager.createSession(projectPath);
-
-    if (session) {
-      this.socket?.emit('session_created', {
-        genboxId: this.genboxId,
-        sessionId: session.sessionId,
-        sessionName: session.sessionName,
-        projectPath: session.projectPath,
-        requestId,
-        success: true,
-      });
-
-      // Start output polling for this session
-      this.startOutputPolling(session.sessionId);
-    } else {
-      this.socket?.emit('session_created', {
-        genboxId: this.genboxId,
-        requestId,
-        success: false,
-        error: 'Failed to create session',
-      });
-    }
-  }
-
-  private onGetOutput(data: RequestData): void {
-    const { sessionId, lines = 100, requestId } = data;
-    if (!sessionId) return;
-
-    const output = this.sessionManager.getOutput(sessionId, lines);
-    const status = this.sessionManager.getSessionStatus(sessionId);
-
-    this.socket?.emit('output_update', {
-      genboxId: this.genboxId,
-      sessionId,
-      requestId,
-      output: output || '',
-      status,
-    });
-  }
-
-  private onKillSession(data: RequestData): void {
-    const { sessionId, requestId } = data;
-    if (!sessionId) return;
-
-    console.log(`[${this.genboxId}] Killing session ${sessionId}`);
-
-    const success = this.sessionManager.killSession(sessionId);
-    this.stopOutputPolling(sessionId);
-
-    this.socket?.emit('session_killed', {
-      genboxId: this.genboxId,
-      sessionId,
-      requestId,
-      success,
-    });
-  }
-
-  private onListSessions(data: RequestData): void {
-    const { requestId } = data;
-
-    const sessions = this.sessionManager.listSessions();
-
-    this.socket?.emit('sessions_list', {
-      genboxId: this.genboxId,
-      requestId,
-      sessions,
-    });
-  }
-
-  private onError(data: any): void {
-    console.error(`[${this.genboxId}] Error from server:`, data);
-  }
-
-  private startOutputPolling(sessionId: string): void {
-    if (this.outputPollers.has(sessionId)) return;
-
-    let lastOutput = '';
-
-    const poller = setInterval(() => {
-      if (!this.running) {
-        this.stopOutputPolling(sessionId);
-        return;
-      }
-
-      const output = this.sessionManager.getOutput(sessionId, 100);
-      const status = this.sessionManager.getSessionStatus(sessionId);
-
-      // Only send if output changed
-      if (output && output !== lastOutput) {
-        lastOutput = output;
-        this.socket?.emit('output_update', {
-          genboxId: this.genboxId,
-          sessionId,
-          output,
-          status,
-        });
-      }
-
-      // Stop polling if session ended
-      if (status === 'ended') {
-        this.stopOutputPolling(sessionId);
-      }
-    }, OUTPUT_POLL_INTERVAL);
-
-    this.outputPollers.set(sessionId, poller);
-  }
-
-  private stopOutputPolling(sessionId: string): void {
-    const poller = this.outputPollers.get(sessionId);
-    if (poller) {
-      clearInterval(poller);
-      this.outputPollers.delete(sessionId);
-    }
-  }
-
-  private captureAndSendOutput(sessionId: string): void {
-    const output = this.sessionManager.getOutput(sessionId, 100);
-    const status = this.sessionManager.getSessionStatus(sessionId);
-
-    if (output && this.socket?.connected) {
-      this.socket.emit('output_update', {
-        genboxId: this.genboxId,
-        sessionId,
-        output,
-        status,
-      });
-    }
-  }
-
-  async run(): Promise<void> {
-    console.log(`Starting Genbox Agent Daemon for ${this.genboxId}`);
-
-    const connected = await this.connect();
-    if (!connected) {
-      console.log('Initial connection failed, will keep retrying...');
-    }
-
-    // Keep running
-    await new Promise<void>((resolve) => {
-      const shutdown = () => {
-        console.log('Shutting down...');
-        this.running = false;
-
-        // Stop all output pollers
-        for (const sessionId of this.outputPollers.keys()) {
-          this.stopOutputPolling(sessionId);
-        }
-
-        this.socket?.disconnect();
-        resolve();
-      };
-
-      process.on('SIGTERM', shutdown);
-      process.on('SIGINT', shutdown);
-    });
-  }
-}
-
-// Main entry point
-async function main(): Promise<void> {
-  if (!GENBOX_ID) {
-    console.error('Error: GENBOX_ID environment variable not set');
-    process.exit(1);
-  }
-
-  if (!GENBOX_TOKEN) {
-    console.error('Error: GENBOX_TOKEN environment variable not set');
-    process.exit(1);
-  }
-
-  const daemon = new GenboxAgentDaemon(GENBOX_ID, GENBOX_TOKEN, MONITORING_WS_URL);
-  await daemon.run();
-}
-
-main().catch((error) => {
-  console.error('Fatal error:', error);
-  process.exit(1);
-});

package/src/hook.ts

@@ -1,200 +0,0 @@
-#!/usr/bin/env node
-/**
- * Claude Code Hook Script
- *
- * Called by Claude Code hooks to report all interactions to the backend.
- * This script reads from stdin (hook input) and POSTs to the monitoring API.
- *
- * Environment variables:
- * - GENBOX_ID: Unique identifier for this genbox
- * - GENBOX_TOKEN: Authentication token for the API
- * - MONITORING_API_URL: Base URL for the monitoring API
- * - CLAUDE_HOOK_TYPE: The type of hook being called (set by Claude Code)
- */
-
-import * as fs from 'fs';
-import * as path from 'path';
-import * as crypto from 'crypto';
-import * as http from 'http';
-import * as https from 'https';
-
-// Configuration
-const GENBOX_ID = process.env.GENBOX_ID || '';
-const GENBOX_TOKEN = process.env.GENBOX_TOKEN || '';
-const MONITORING_API_URL = process.env.MONITORING_API_URL || 'http://localhost:3001';
-const HOOK_TYPE = process.env.CLAUDE_HOOK_TYPE || 'Unknown';
-
-// Session file path
-const SESSION_FILE = path.join(process.env.HOME || '/tmp', '.claude-session-id');
-
-function getOrCreateSessionId(): string {
-  try {
-    if (fs.existsSync(SESSION_FILE)) {
-      return fs.readFileSync(SESSION_FILE, 'utf-8').trim();
-    }
-  } catch {
-    // Ignore read errors
-  }
-
-  // Generate new session ID
-  const sessionId = crypto
-    .createHash('sha256')
-    .update(`${GENBOX_ID}-${Date.now()}-${process.pid}`)
-    .digest('hex')
-    .slice(0, 32);
-
-  try {
-    fs.writeFileSync(SESSION_FILE, sessionId);
-  } catch {
-    // Ignore write errors
-  }
-
-  return sessionId;
-}
-
-function clearSessionId(): void {
-  try {
-    if (fs.existsSync(SESSION_FILE)) {
-      fs.unlinkSync(SESSION_FILE);
-    }
-  } catch {
-    // Ignore errors
-  }
-}
-
-function getTmuxSession(): string | undefined {
-  if (process.env.TMUX) {
-    const tmuxPane = process.env.TMUX_PANE || '';
-    return tmuxPane.split(',')[0] || undefined;
-  }
-  return undefined;
-}
-
-async function sendEvent(eventData: Record<string, any>): Promise<boolean> {
-  if (!GENBOX_ID || !GENBOX_TOKEN) {
-    console.error('Warning: GENBOX_ID or GENBOX_TOKEN not set, skipping event');
-    return false;
-  }
-
-  const url = new URL('/claude/events', MONITORING_API_URL);
-
-  // Add metadata
-  eventData.genboxId = GENBOX_ID;
-  eventData.genboxToken = GENBOX_TOKEN;
-  eventData.sessionId = getOrCreateSessionId();
-  eventData.tmuxSession = getTmuxSession();
-  eventData.projectPath = process.cwd();
-  eventData.timestamp = new Date().toISOString();
-
-  const data = JSON.stringify(eventData);
-  const isHttps = url.protocol === 'https:';
-
-  return new Promise((resolve) => {
-    const options = {
-      hostname: url.hostname,
-      port: url.port || (isHttps ? 443 : 80),
-      path: url.pathname,
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'Content-Length': Buffer.byteLength(data),
-        'X-Genbox-Token': GENBOX_TOKEN,
-      },
-      timeout: 5000,
-    };
-
-    const req = (isHttps ? https : http).request(options, (res) => {
-      resolve(res.statusCode === 200 || res.statusCode === 201);
-    });
-
-    req.on('error', (error) => {
-      console.error(`Warning: Failed to send event: ${error.message}`);
-      resolve(false);
-    });
-
-    req.on('timeout', () => {
-      req.destroy();
-      console.error('Warning: Request timeout');
-      resolve(false);
-    });
-
-    req.write(data);
-    req.end();
-  });
-}
-
-function parseHookInput(input: string): Record<string, any> {
-  try {
-    if (!input.trim()) {
-      return {};
-    }
-    return JSON.parse(input);
-  } catch {
-    return { raw_input: input };
-  }
-}
-
-async function main(): Promise<void> {
-  // Read input from stdin
-  let input = '';
-  if (!process.stdin.isTTY) {
-    input = fs.readFileSync(0, 'utf-8');
-  }
-
-  const hookInput = parseHookInput(input);
-
-  // Build event data based on hook type
-  const eventData: Record<string, any> = {
-    eventType: HOOK_TYPE,
-  };
-
-  switch (HOOK_TYPE) {
-    case 'PreToolUse':
-      eventData.toolName = hookInput.tool_name || '';
-      eventData.toolInput = hookInput.tool_input || {};
-      break;
-
-    case 'PostToolUse':
-      eventData.toolName = hookInput.tool_name || '';
-      eventData.toolInput = hookInput.tool_input || {};
-      eventData.toolResponse = hookInput.tool_response || {};
-      eventData.success = hookInput.tool_response?.success !== false;
-      break;
-
-    case 'UserPromptSubmit':
-      const prompt = hookInput.prompt || '';
-      eventData.prompt = prompt;
-      eventData.promptLength = prompt.length;
-      break;
-
-    case 'Stop':
-      eventData.stopReason = hookInput.stop_reason || '';
-      break;
-
-    case 'SubagentStop':
-      eventData.subagentType = hookInput.subagent_type || '';
-      eventData.stopReason = hookInput.stop_reason || '';
-      break;
-
-    case 'Notification':
-      eventData.notification = hookInput.message || '';
-      break;
-
-    case 'SessionStart':
-      eventData.cliVersion = hookInput.cli_version || '';
-      break;
-
-    case 'SessionEnd':
-      clearSessionId();
-      eventData.sessionDuration = hookInput.duration_ms || 0;
-      break;
-  }
-
-  // Send the event (don't await - fire and forget)
-  sendEvent(eventData).catch(() => {});
-
-  // Exit immediately - hooks should not block Claude
-  process.exit(0);
-}
-
-main().catch(() => process.exit(0));

package/src/index.ts

@@ -1 +0,0 @@
-export { SessionManager, ClaudeSession } from './session-manager';