@yeego/yeego-openclaw 1.0.0

package/openclaw.plugin.json

@@ -0,0 +1,31 @@
+{
+  "id": "yeego-openclaw",
+  "channels": ["yeego"],
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {
+      "token": {
+        "type": "string",
+        "description": "Yeego authentication token"
+      },
+      "profileId": {
+        "type": "string",
+        "description": "Yeego profile ID"
+      },
+      "baseUrl": {
+        "type": "string",
+        "description": "Yeego base URL"
+      },
+      "sidecarUrl": {
+        "type": "string",
+        "description": "Yeego sidecar URL"
+      },
+      "connectUrl": {
+        "type": "string",
+        "description": "Yeego connect endpoint URL"
+      }
+    },
+    "required": ["token", "profileId", "baseUrl", "sidecarUrl", "connectUrl"]
+  }
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@yeego/yeego-openclaw",
+  "version": "1.0.0",
+  "description": "Yeego plugin for OpenClaw - Connect your AI personas",
+  "main": "index.ts",
+  "type": "module",
+  "bin": {
+    "yeego-poller": "./poller.ts"
+  },
+  "scripts": {
+    "setup": "bun run poller.ts setup",
+    "start": "bun run poller.ts start",
+    "build": "bun build poller.ts --compile --outfile yeego-poller"
+  },
+  "keywords": [
+    "yeego",
+    "openclaw",
+    "ai",
+    "chatbot",
+    "plugin"
+  ],
+  "author": "Yeego Team",
+  "license": "MIT",
+  "homepage": "https://yeego.app",
+  "openclaw": {
+    "extensions": ["./index.ts"]
+  },
+  "files": [
+    "index.ts",
+    "poller.ts",
+    "src/",
+    "openclaw.plugin.json",
+    "README.md",
+    "QUICKSTART.md"
+  ],
+  "dependencies": {
+    "@sinclair/typebox": "^0.34.18",
+    "eventsource": "^4.1.0",
+    "pocketbase": "^0.26.8",
+    "tsx": "^4.21.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0"
+  }
+}

package/poller.ts

@@ -0,0 +1,516 @@
+#!/usr/bin/env node
+/**
+ * Yeego OpenClaw Plugin - Message Poller
+ *
+ * Polls PocketBase for new user messages and processes them through OpenClaw agent.
+ */
+
+import PocketBase from 'pocketbase';
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { spawn, ChildProcess } from 'child_process';
+import { setSessionConversation } from './src/sessionMapping.js';
+
+// ============================================================================
+// Types
+// ============================================================================
+
+interface YeegoConfig {
+  token: string;
+  profile_id: string;
+  base_url: string;
+  sidecar_url?: string;
+}
+
+interface PocketBaseMessage {
+  id: string;
+  conversation: string;
+  message: string;
+  by: 'user' | 'persona';
+  is_ai_generated: boolean;
+  has_finished_generating?: boolean;
+  created: string;
+}
+
+interface PocketBaseConversation {
+  id: string;
+  profile: string;
+}
+
+interface OpenClawResponse {
+  result?: {
+    payloads?: Array<{ text?: string }>;
+  };
+  text?: string;
+}
+
+// ============================================================================
+// Constants
+// ============================================================================
+
+const CONFIG_DIR = join(homedir(), '.yeego');
+const CONFIG_FILE = join(CONFIG_DIR, 'config.json');
+const PROCESSED_FILE = join(CONFIG_DIR, 'processed.json');
+const SESSION_METADATA_DELAY_MS = 1000;
+const POLL_INTERVAL_MS = 5000; // Poll every 5 seconds (avoid rate limiting)
+
+// ============================================================================
+// Main Poller Class
+// ============================================================================
+
+class YeegoPoller {
+  private readonly config: YeegoConfig;
+  private readonly pb: PocketBase;
+  private readonly processedMessages: Set<string>;
+  private isRunning = false;
+  private pollInterval?: NodeJS.Timeout;
+
+  constructor(config: YeegoConfig) {
+    this.config = config;
+    this.pb = new PocketBase(config.base_url);
+    this.pb.autoCancellation(false); // Disable auto-cancellation to allow updates during realtime subscription
+    this.pb.authStore.save(config.token);
+    this.processedMessages = this.loadProcessedMessages();
+  }
+
+  // --------------------------------------------------------------------------
+  // Persistence
+  // --------------------------------------------------------------------------
+
+  private loadProcessedMessages(): Set<string> {
+    try {
+      if (existsSync(PROCESSED_FILE)) {
+        const data = JSON.parse(readFileSync(PROCESSED_FILE, 'utf-8'));
+        return new Set(data);
+      }
+    } catch (error) {
+      console.error('[Yeego] Failed to load processed messages:', error);
+    }
+    return new Set();
+  }
+
+  private saveProcessedMessages(): void {
+    try {
+      writeFileSync(
+        PROCESSED_FILE,
+        JSON.stringify(Array.from(this.processedMessages)),
+        'utf-8'
+      );
+    } catch (error) {
+      console.error('[Yeego] Failed to save processed messages:', error);
+    }
+  }
+
+  // --------------------------------------------------------------------------
+  // Connection
+  // --------------------------------------------------------------------------
+
+  async connect(): Promise<void> {
+    try {
+      console.log('[Yeego] Connecting to Yeego API...');
+
+      const sidecarUrl = this.config.sidecar_url || this.config.base_url;
+      await fetch(`${sidecarUrl}/public/openclaw/connect`, {
+        method: 'POST',
+        body: JSON.stringify({
+          profile_id: this.config.profile_id,
+        }),
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${this.config.token}`,
+        },
+      });
+
+      console.log('[Yeego] Connected successfully');
+    } catch (error) {
+      console.error('[Yeego] Connection failed:', error);
+      throw error;
+    }
+  }
+
+  // --------------------------------------------------------------------------
+  // Message Processing
+  // --------------------------------------------------------------------------
+
+  async checkAndProcessLastMessage(conversationId: string): Promise<void> {
+    try {
+      const conversation = await this.pb
+        .collection('profile_chat_conversations')
+        .getOne<PocketBaseConversation>(conversationId);
+
+      if (conversation.profile !== this.config.profile_id) {
+        return;
+      }
+
+      const lastMessages = await this.pb
+        .collection('profile_chat_messages')
+        .getList<PocketBaseMessage>(1, 1, {
+          filter: `conversation="${conversationId}"`,
+          sort: '-created',
+        });
+
+      if (lastMessages.items.length === 0) {
+        return;
+      }
+
+      const lastMessage = lastMessages.items[0];
+
+      if (lastMessage.by === 'user' && !lastMessage.is_ai_generated) {
+        if (!this.processedMessages.has(lastMessage.id)) {
+          await this.processMessage(lastMessage, conversation);
+          this.processedMessages.add(lastMessage.id);
+          this.saveProcessedMessages();
+        }
+      }
+    } catch (error) {
+      console.error('[Yeego] Error checking last message:', error);
+    }
+  }
+
+  private async processMessage(
+    message: PocketBaseMessage,
+    conversation: PocketBaseConversation
+  ): Promise<void> {
+    let placeholderId: string | null = null;
+
+    try {
+      console.log(`[Yeego] Processing message: ${message.id}`);
+
+      // Create placeholder message to show loading state
+      const placeholder = await this.pb.collection('profile_chat_messages').create({
+        conversation: conversation.id,
+        message: '',
+        by: 'persona',
+        is_ai_generated: true,
+        has_finished_generating: false,
+        source: 'openclaw',
+      });
+      placeholderId = placeholder.id;
+      console.log(`[Yeego] Created placeholder: ${placeholderId}`);
+
+      this.saveSessionMapping(conversation.id);
+
+      const aiText = await this.callOpenClawAgent(message, conversation);
+      console.log(`[Yeego] Got AI response, updating placeholder...`);
+
+      // Update placeholder with AI response
+      await this.pb.collection('profile_chat_messages').update(placeholderId, {
+        conversation: conversation.id,
+        message: aiText,
+        has_finished_generating: true,
+      });
+      console.log(`[Yeego] Update completed!`);
+
+      // Workaround: Set messageChannel in session file after agent creates it
+      setTimeout(() => {
+        this.setSessionMessageChannel(conversation.id, 'yeego');
+      }, SESSION_METADATA_DELAY_MS);
+
+      console.log(`[Yeego] ✓ Processed message ${message.id}`);
+    } catch (error) {
+      console.error(`[Yeego] Error processing message:`, error);
+
+      // Clean up placeholder on error
+      if (placeholderId) {
+        try {
+          await this.pb.collection('profile_chat_messages').delete(placeholderId);
+        } catch (deleteError) {
+          console.error(`[Yeego] Failed to delete placeholder:`, deleteError);
+        }
+      }
+    }
+  }
+
+  private saveSessionMapping(conversationId: string): void {
+    console.log(`[Yeego] Saving session mappings for conversation: ${conversationId}`);
+    setSessionConversation(conversationId, conversationId);
+    setSessionConversation(`agent:main:${conversationId}`, conversationId);
+    setSessionConversation(`yeego:${conversationId}`, conversationId);
+  }
+
+  private async callOpenClawAgent(
+    message: PocketBaseMessage,
+    conversation: PocketBaseConversation
+  ): Promise<string> {
+    const proc = spawn('openclaw', [
+      'agent',
+      '--session-id',
+      conversation.id,
+      '--reply-channel',
+      'yeego',
+      '--reply-to',
+      conversation.id,
+      '--message',
+      message.message,
+      '--json',
+    ], {
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+
+    const { stdout, stderr, exitCode } = await this.captureProcessOutput(proc);
+
+    if (exitCode !== 0) {
+      console.error(`[Yeego] OpenClaw error:`, stderr);
+      return 'Error processing message';
+    }
+
+    return this.parseOpenClawResponse(stdout);
+  }
+
+  private captureProcessOutput(proc: ChildProcess): Promise<{
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+  }> {
+    return new Promise((resolve) => {
+      let stdout = '';
+      let stderr = '';
+
+      proc.stdout?.on('data', (data) => {
+        stdout += data.toString();
+      });
+
+      proc.stderr?.on('data', (data) => {
+        stderr += data.toString();
+      });
+
+      proc.on('close', (code) => {
+        resolve({ stdout, stderr, exitCode: code || 0 });
+      });
+    });
+  }
+
+  private parseOpenClawResponse(output: string): string {
+    try {
+      const jsonMatch = output.match(/\{[\s\S]*\}/);
+      if (jsonMatch) {
+        const result: any = JSON.parse(jsonMatch[0]);
+
+        // Try to find payloads in different locations
+        let payloads = result.result?.payloads || result.payloads;
+
+        if (payloads && payloads.length > 0) {
+          const texts = payloads
+            .map((p: any) => p.text)
+            .filter((t: string) => t && t.trim())
+            .join('\n\n');
+          return texts || 'No response';
+        }
+
+        return result.text || 'No response';
+      }
+      return output.trim() || 'No response';
+    } catch (error) {
+      console.error(`[Yeego] Failed to parse OpenClaw response:`, error);
+      return output.trim() || 'No response';
+    }
+  }
+
+  private async createAIResponse(conversationId: string, text: string): Promise<void> {
+    await this.pb.collection('profile_chat_messages').create({
+      conversation: conversationId,
+      message: text,
+      by: 'persona',
+      is_ai_generated: true,
+      has_finished_generating: true,
+      source: 'openclaw',
+    });
+  }
+
+  // --------------------------------------------------------------------------
+  // Session Metadata Workaround
+  // --------------------------------------------------------------------------
+
+  /**
+   * Sets messageChannel in OpenClaw session metadata file.
+   * This is a workaround because --reply-channel CLI flag doesn't set the session's messageChannel property.
+   */
+  private setSessionMessageChannel(sessionId: string, channel: string): boolean {
+    try {
+      const sessionDir = join(homedir(), '.openclaw', 'agents', 'main', 'sessions');
+      const sessionFile = join(sessionDir, `${sessionId}.jsonl`);
+
+      if (!existsSync(sessionFile)) {
+        console.log(`[Yeego] Session file not found yet: ${sessionFile}`);
+        return false;
+      }
+
+      const lines = readFileSync(sessionFile, 'utf-8')
+        .split('\n')
+        .filter(l => l.trim());
+
+      if (lines.length === 0) {
+        return false;
+      }
+
+      const firstLine = JSON.parse(lines[0]);
+      if (firstLine.type === 'session') {
+        firstLine.messageChannel = channel;
+        lines[0] = JSON.stringify(firstLine);
+        writeFileSync(sessionFile, lines.join('\n') + '\n', 'utf-8');
+        console.log(`[Yeego] ✓ Set messageChannel="${channel}" for session ${sessionId}`);
+        return true;
+      }
+
+      return false;
+    } catch (error) {
+      console.error(`[Yeego] Failed to set messageChannel:`, error);
+      return false;
+    }
+  }
+
+  // --------------------------------------------------------------------------
+  // Polling
+  // --------------------------------------------------------------------------
+
+  private async pollForNewMessages(): Promise<void> {
+    try {
+      // Get recent messages from the last 10 seconds
+      const tenSecondsAgo = new Date(Date.now() - 10000).toISOString().replace('T', ' ').substring(0, 19);
+      const messages = await this.pb.collection('profile_chat_messages').getList<PocketBaseMessage>(1, 50, {
+        filter: `created >= "${tenSecondsAgo}" && by = "user" && is_ai_generated = false`,
+        sort: '-created',
+      });
+
+      for (const message of messages.items) {
+        if (!this.processedMessages.has(message.id) && message.conversation) {
+          console.log(`[Yeego] New message detected: ${message.id}`);
+          await this.checkAndProcessLastMessage(message.conversation);
+        }
+      }
+    } catch (error) {
+      console.error('[Yeego] Error polling messages:', error);
+    }
+  }
+
+  // --------------------------------------------------------------------------
+  // Lifecycle
+  // --------------------------------------------------------------------------
+
+  async start(): Promise<void> {
+    if (this.isRunning) {
+      console.log('[Yeego] Already running');
+      return;
+    }
+
+    this.isRunning = true;
+    console.log('[Yeego] Starting poller...');
+
+    await this.connect();
+
+    console.log('[Yeego] Starting to poll for new messages...');
+
+    // Poll for new messages at regular intervals
+    this.pollInterval = setInterval(() => {
+      if (this.isRunning) {
+        this.pollForNewMessages();
+      }
+    }, POLL_INTERVAL_MS);
+
+    console.log('[Yeego] Polling for messages...');
+
+    return new Promise<void>((resolve) => {
+      const checkInterval = setInterval(() => {
+        if (!this.isRunning) {
+          clearInterval(checkInterval);
+          resolve();
+        }
+      }, 1000);
+    });
+  }
+
+  stop(): void {
+    this.isRunning = false;
+    if (this.pollInterval) {
+      clearInterval(this.pollInterval);
+      this.pollInterval = undefined;
+    }
+    console.log('[Yeego] Stopped');
+  }
+}
+
+// ============================================================================
+// CLI Commands
+// ============================================================================
+
+async function setup(configText: string): Promise<void> {
+  try {
+    console.log('[Yeego] Setting up configuration...');
+
+    const config: Partial<YeegoConfig> = {};
+    configText.split('\n').forEach(line => {
+      line = line.trim();
+      if (line && !line.startsWith('#')) {
+        const match = line.match(/^(\w+)=(.+)$/);
+        if (match) {
+          const [, key, value] = match;
+          if (key === 'YEEGO_TOKEN') config.token = value;
+          else if (key === 'YEEGO_PROFILE_ID') config.profile_id = value;
+          else if (key === 'YEEGO_BASE_URL') config.base_url = value;
+          else if (key === 'YEEGO_SIDECAR_URL') config.sidecar_url = value;
+        }
+      }
+    });
+
+    if (!config.token || !config.profile_id || !config.base_url) {
+      throw new Error('Missing required configuration: token, profile_id, or base_url');
+    }
+
+    if (!existsSync(CONFIG_DIR)) {
+      mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+
+    writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), 'utf-8');
+    console.log('[Yeego] Configuration saved to', CONFIG_FILE);
+  } catch (error) {
+    console.error('[Yeego] Setup failed:', error);
+    process.exit(1);
+  }
+}
+
+async function start(): Promise<void> {
+  try {
+    if (!existsSync(CONFIG_FILE)) {
+      console.error('[Yeego] Configuration not found. Run setup first.');
+      process.exit(1);
+    }
+
+    const config: YeegoConfig = JSON.parse(readFileSync(CONFIG_FILE, 'utf-8'));
+    const poller = new YeegoPoller(config);
+
+    const shutdown = () => {
+      console.log('\n[Yeego] Shutting down...');
+      poller.stop();
+      process.exit(0);
+    };
+
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+
+    await poller.start();
+  } catch (error) {
+    console.error('[Yeego] Fatal error:', error);
+    process.exit(1);
+  }
+}
+
+// ============================================================================
+// Main Entry Point
+// ============================================================================
+
+const command = process.argv[2];
+const arg = process.argv[3];
+
+if (command === 'setup') {
+  if (!arg) {
+    console.error('Usage: poller.ts setup <config-text>');
+    process.exit(1);
+  }
+  setup(arg);
+} else if (command === 'start') {
+  start();
+} else {
+  console.error('Usage: poller.ts {setup|start}');
+  process.exit(1);
+}