genbox-agent 0.0.2

package/src/hook.ts

@@ -0,0 +1,200 @@
+#!/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

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

package/src/session-manager.ts

@@ -0,0 +1,270 @@
+import { execSync, spawn } from 'child_process';
+import * as crypto from 'crypto';
+
+export interface ClaudeSession {
+  sessionName: string;
+  sessionId: string;
+  projectPath: string;
+  createdAt: number;
+  status: string;
+}
+
+/**
+ * Manages tmux sessions running Claude Code.
+ */
+export class SessionManager {
+  private readonly TMUX_PREFIX = 'claude-';
+  private sessions: Map<string, ClaudeSession> = new Map();
+
+  constructor(private readonly genboxId: string) {}
+
+  private runTmux(args: string[], timeout = 10000): { stdout: string; stderr: string; success: boolean } {
+    try {
+      const stdout = execSync(`tmux ${args.join(' ')}`, {
+        timeout,
+        encoding: 'utf-8',
+        stdio: ['pipe', 'pipe', 'pipe'],
+      });
+      return { stdout: stdout || '', stderr: '', success: true };
+    } catch (error: any) {
+      return {
+        stdout: error.stdout?.toString() || '',
+        stderr: error.stderr?.toString() || error.message,
+        success: false,
+      };
+    }
+  }
+
+  private generateSessionId(): string {
+    return crypto
+      .createHash('sha256')
+      .update(`${this.genboxId}-${Date.now()}-${process.pid}`)
+      .digest('hex')
+      .slice(0, 16);
+  }
+
+  /**
+   * Create a new Claude Code session in tmux.
+   */
+  createSession(projectPath = '/home/dev'): ClaudeSession | null {
+    const sessionId = this.generateSessionId();
+    const sessionName = `${this.TMUX_PREFIX}${sessionId}`;
+
+    // Create a new detached tmux session
+    const result = this.runTmux([
+      'new-session',
+      '-d',
+      '-s', sessionName,
+      '-c', projectPath,
+    ]);
+
+    if (!result.success) {
+      console.error(`Failed to create tmux session: ${result.stderr}`);
+      return null;
+    }
+
+    // Give tmux a moment to initialize
+    execSync('sleep 0.5');
+
+    // Start Claude Code in the session
+    this.runTmux([
+      'send-keys',
+      '-t', sessionName,
+      'claude',
+      'Enter',
+    ]);
+
+    const session: ClaudeSession = {
+      sessionName,
+      sessionId,
+      projectPath,
+      createdAt: Date.now(),
+      status: 'active',
+    };
+
+    this.sessions.set(sessionId, session);
+    return session;
+  }
+
+  /**
+   * Send a prompt to a Claude Code session.
+   */
+  sendPrompt(sessionId: string, prompt: string): boolean {
+    const session = this.sessions.get(sessionId);
+    const sessionName = session?.sessionName || `${this.TMUX_PREFIX}${sessionId}`;
+
+    // Send the prompt text with literal flag to handle special characters
+    const textResult = this.runTmux([
+      'send-keys',
+      '-t', sessionName,
+      '-l', // Literal flag
+      `"${prompt.replace(/"/g, '\\"')}"`,
+    ]);
+
+    if (!textResult.success) {
+      console.error(`Failed to send prompt text: ${textResult.stderr}`);
+      return false;
+    }
+
+    // Send Enter to submit the prompt
+    const enterResult = this.runTmux([
+      'send-keys',
+      '-t', sessionName,
+      'Enter',
+    ]);
+
+    if (!enterResult.success) {
+      console.error(`Failed to send Enter: ${enterResult.stderr}`);
+      return false;
+    }
+
+    return true;
+  }
+
+  /**
+   * Send a keystroke to a Claude Code session.
+   */
+  sendKeystroke(sessionId: string, key: string): boolean {
+    const session = this.sessions.get(sessionId);
+    const sessionName = session?.sessionName || `${this.TMUX_PREFIX}${sessionId}`;
+
+    // Map common key names to tmux key names
+    const keyMap: Record<string, string> = {
+      enter: 'Enter',
+      escape: 'Escape',
+      up: 'Up',
+      down: 'Down',
+      left: 'Left',
+      right: 'Right',
+      tab: 'Tab',
+      backspace: 'BSpace',
+      delete: 'DC',
+      'ctrl-c': 'C-c',
+      'ctrl-d': 'C-d',
+      'ctrl-z': 'C-z',
+      y: 'y',
+      n: 'n',
+    };
+
+    const tmuxKey = keyMap[key.toLowerCase()] || key;
+
+    const result = this.runTmux([
+      'send-keys',
+      '-t', sessionName,
+      tmuxKey,
+    ]);
+
+    return result.success;
+  }
+
+  /**
+   * Capture the terminal output from a session.
+   */
+  getOutput(sessionId: string, lines = 100): string | null {
+    const session = this.sessions.get(sessionId);
+    const sessionName = session?.sessionName || `${this.TMUX_PREFIX}${sessionId}`;
+
+    const result = this.runTmux([
+      'capture-pane',
+      '-t', sessionName,
+      '-p', // Print to stdout
+      '-S', `-${lines}`, // Start from lines back
+    ]);
+
+    return result.success ? result.stdout : null;
+  }
+
+  /**
+   * Get the status of a session.
+   */
+  getSessionStatus(sessionId: string): string {
+    const session = this.sessions.get(sessionId);
+    const sessionName = session?.sessionName || `${this.TMUX_PREFIX}${sessionId}`;
+
+    // Check if session exists
+    const hasSession = this.runTmux(['has-session', '-t', sessionName]);
+    if (!hasSession.success) {
+      return 'ended';
+    }
+
+    // Get pane content to determine status
+    const output = this.getOutput(sessionId, 10);
+    if (output) {
+      const lowerOutput = output.toLowerCase();
+      const lastLine = output.split('\n').pop() || '';
+
+      if (lowerOutput.includes('waiting for input') || lastLine.includes('>')) {
+        return 'waiting_input';
+      }
+      if (lowerOutput.includes('error')) {
+        return 'error';
+      }
+      if (lowerOutput.includes('thinking') || lowerOutput.includes('working')) {
+        return 'active';
+      }
+    }
+
+    return 'idle';
+  }
+
+  /**
+   * Kill a Claude Code session.
+   */
+  killSession(sessionId: string): boolean {
+    const session = this.sessions.get(sessionId);
+    const sessionName = session?.sessionName || `${this.TMUX_PREFIX}${sessionId}`;
+
+    const result = this.runTmux(['kill-session', '-t', sessionName]);
+
+    if (result.success) {
+      this.sessions.delete(sessionId);
+    }
+
+    return result.success;
+  }
+
+  /**
+   * List all Claude Code sessions.
+   */
+  listSessions(): Array<{
+    sessionId: string;
+    sessionName: string;
+    createdAt: number;
+    status: string;
+  }> {
+    const result = this.runTmux([
+      'list-sessions',
+      '-F', '#{session_name}:#{session_created}',
+    ]);
+
+    if (!result.success) {
+      return [];
+    }
+
+    const sessions: Array<{
+      sessionId: string;
+      sessionName: string;
+      createdAt: number;
+      status: string;
+    }> = [];
+
+    for (const line of result.stdout.trim().split('\n')) {
+      if (!line || !line.startsWith(this.TMUX_PREFIX)) {
+        continue;
+      }
+
+      const [sessionName, createdAtStr] = line.split(':');
+      const sessionId = sessionName.replace(this.TMUX_PREFIX, '');
+      const createdAt = parseInt(createdAtStr, 10) * 1000 || 0;
+
+      sessions.push({
+        sessionId,
+        sessionName,
+        createdAt,
+        status: this.getSessionStatus(sessionId),
+      });
+    }
+
+    return sessions;
+  }
+}

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "lib": ["ES2022"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}