@openclaw-cloud/agent-controller 0.2.6 → 0.2.7

package/src/heartbeat.ts

@@ -1,110 +0,0 @@
-import os from 'node:os';
-import path from 'node:path';
-import fs from 'node:fs/promises';
-import { exec } from 'node:child_process';
-import { debugLog } from './debug.js';
-import type { AgentApi } from './api.js';
-import type { BoardState, HeartbeatPayload } from './types.js';
-import { selfUpdate } from './commands/self-update.js';
-
-const HEARTBEAT_INTERVAL = 30_000;
-const UPDATE_CHECK_INTERVAL = 24 * 60 * 60 * 1000; // 24h
-const PACKAGE_NAME = '@openclaw-cloud/agent-controller';
-
-function execAsync(cmd: string, timeout: number): Promise<string> {
-  return new Promise((resolve, reject) => {
-    exec(cmd, { timeout }, (err, stdout) => {
-      if (err) reject(err);
-      else resolve(stdout.toString().trim());
-    });
-  });
-}
-
-async function checkForUpdate(currentVersion: string): Promise<void> {
-  try {
-    const latest = await execAsync(`npm view ${PACKAGE_NAME} version`, 10_000);
-    if (latest && latest !== currentVersion) {
-      console.log(`[update] New version available: ${latest} (current: ${currentVersion}). Updating...`);
-      await selfUpdate(currentVersion);
-    }
-  } catch {
-    // No internet, npm unavailable, or already up to date — silently ignore
-  }
-}
-
-export async function getLastMessageAt(): Promise<string | null> {
-  const stateDir = process.env.OPENCLAW_STATE_DIR?.trim()
-    ?? path.join(os.homedir(), '.openclaw');
-  const sessionsDir = path.join(stateDir, 'agents', 'main', 'sessions');
-  try {
-    const files = await fs.readdir(sessionsDir);
-    const jsonlFiles = files.filter((f) => f.endsWith('.jsonl'));
-    if (jsonlFiles.length === 0) return null;
-    const mtimes = await Promise.all(
-      jsonlFiles.map((f) =>
-        fs.stat(path.join(sessionsDir, f)).then((s) => s.mtime.getTime())
-      )
-    );
-    return new Date(Math.max(...mtimes)).toISOString();
-  } catch {
-    return null;
-  }
-}
-
-export interface HeartbeatOptions {
-  api: AgentApi;
-  agentId: string;
-  version: string;
-  getBoardStatus?: () => BoardState;
-}
-
-function getMetrics(): HeartbeatPayload['metrics'] {
-  const cpus = os.cpus();
-  const cpuUsage = cpus.reduce((acc, cpu) => {
-    const total = Object.values(cpu.times).reduce((a, b) => a + b, 0);
-    return acc + (1 - cpu.times.idle / total);
-  }, 0) / cpus.length;
-
-  const totalMem = os.totalmem();
-  const freeMem = os.freemem();
-
-  return {
-    cpu: Math.round(cpuUsage * 100) / 100,
-    mem: Math.round(((totalMem - freeMem) / totalMem) * 100) / 100,
-    uptime: os.uptime(),
-  };
-}
-
-async function publishHeartbeat(opts: HeartbeatOptions): Promise<void> {
-  const payload: HeartbeatPayload = {
-    type: 'heartbeat',
-    agentId: opts.agentId,
-    ts: Date.now(),
-    version: opts.version,
-    metrics: getMetrics(),
-    ...(opts.getBoardStatus ? { boardStatus: opts.getBoardStatus() } : {}),
-    lastMessageAt: await getLastMessageAt(),
-  };
-
-  try {
-    debugLog('heartbeat', '→ sending', opts.agentId, JSON.stringify(payload).slice(0, 500));
-    await opts.api.publishHeartbeat(opts.agentId, payload);
-    debugLog('heartbeat', '← ok');
-  } catch (err) {
-    console.error('Heartbeat publish failed:', err instanceof Error ? err.message : err);
-    debugLog('heartbeat', '← error', err);
-  }
-}
-
-export function startHeartbeat(opts: HeartbeatOptions): NodeJS.Timeout {
-  const send = () => { publishHeartbeat(opts).catch(() => {}); };
-  send();
-
-  // Auto-update check: immediately on start, then every 24h
-  checkForUpdate(opts.version).catch(() => {});
-  setInterval(() => { checkForUpdate(opts.version).catch(() => {}); }, UPDATE_CHECK_INTERVAL);
-
-  return setInterval(send, HEARTBEAT_INTERVAL);
-}
-
-export { getMetrics };

package/src/index.ts

@@ -1,97 +0,0 @@
-import { createRequire } from 'node:module';
-import { fileURLToPath } from 'node:url';
-import { dirname, join } from 'node:path';
-import { createConnection } from './connection.js';
-import { startHeartbeat } from './heartbeat.js';
-import { createAgentApi } from './api.js';
-import { BoardHandler } from './handlers/board-handler.js';
-import { createChatProvider } from './openclaw/index.js';
-import { DEBUG } from './debug.js';
-import type { BoardEvent } from './types.js';
-
-const _require = createRequire(import.meta.url);
-const { version: CONTROLLER_VERSION } = _require(join(dirname(fileURLToPath(import.meta.url)), '../package.json')) as { version: string };
-
-function requireEnv(name: string): string {
-  const value = process.env[name];
-  if (!value) {
-    console.error(`Missing required environment variable: ${name}`);
-    process.exit(1);
-  }
-  return value;
-}
-
-export function main(): void {
-  const rawUrl = requireEnv('CENTRIFUGO_URL');
-  // Centrifuge client requires ws:// scheme
-  const url = rawUrl.replace(/^http:\/\//, 'ws://').replace(/^https:\/\//, 'wss://') + '/connection/websocket';
-  const token = requireEnv('AGENT_TOKEN');
-  const agentId = requireEnv('AGENT_ID');
-  const backendUrl = requireEnv('BACKEND_INTERNAL_URL');
-  if (DEBUG) console.log('[debug] Debug mode enabled');
-  console.log(`Starting agent-controller for agent: ${agentId}`);
-  console.log(`Backend URL: ${backendUrl} (JWT mode)`);
-
-  const api = createAgentApi(backendUrl, token);
-  const { client } = createConnection({ url, token, agentId, backendUrl, api, version: CONTROLLER_VERSION });
-
-  // Chat provider via OpenClaw Gateway WS
-  const gatewayWsUrl = process.env.OPENCLAW_GATEWAY_WS || 'ws://localhost:18789';
-  const gatewayToken = process.env.OPENCLAW_GATEWAY_TOKEN || '';
-
-  if (gatewayToken) {
-    const chatProvider = createChatProvider(gatewayWsUrl, gatewayToken);
-    chatProvider.connect().then(() => {
-      console.log('OpenClaw Gateway WS connected (chat provider ready)');
-    }).catch((e) => {
-      console.warn('Chat provider connect failed:', e instanceof Error ? e.message : e);
-    });
-  } else {
-    console.warn('OPENCLAW_GATEWAY_TOKEN not set, chat provider disabled');
-  }
-
-  // Board handler
-  const boardHandler = new BoardHandler(api);
-
-  // Initialize board handler after connection is established
-  boardHandler.initialize().then((workspaceId) => {
-    if (!workspaceId) {
-      console.log('No board found for this agent, board handler dormant');
-      return;
-    }
-
-    const boardChannel = `board:${workspaceId}`;
-    const boardSub = client.newSubscription(boardChannel);
-
-    boardSub.on('publication', (ctx) => {
-      const event = ctx.data as BoardEvent;
-      if (!event || !event.event) return;
-      boardHandler.onBoardEvent(event).catch((err) => {
-        console.error('Board event handler error:', err instanceof Error ? err.message : err);
-      });
-    });
-
-    boardSub.subscribe();
-    console.log(`Subscribed to board channel: ${boardChannel}`);
-  }).catch((err) => {
-    console.error('Board handler init error:', err instanceof Error ? err.message : err);
-  });
-
-  console.log('Heartbeat via backend API');
-  const heartbeatTimer = startHeartbeat({
-    api,
-    agentId,
-    version: CONTROLLER_VERSION,
-    getBoardStatus: () => boardHandler.getBoardStatus(),
-  });
-
-  const shutdown = () => {
-    console.log('Shutting down...');
-    if (heartbeatTimer) clearInterval(heartbeatTimer);
-    client.disconnect();
-    process.exit(0);
-  };
-
-  process.on('SIGINT', shutdown);
-  process.on('SIGTERM', shutdown);
-}

package/src/openclaw/gateway-adapter.ts

@@ -1,129 +0,0 @@
-import { GatewayClient } from './gateway-client.js';
-import type { IChatProvider, ChatSession, ChatMessage, ChatAttachment } from './types.js';
-
-export class OpenclawGatewayAdapter implements IChatProvider {
-  private client: GatewayClient;
-  private streamCallbacks = new Map<string, {
-    onDelta?: (text: string) => void;
-    onDone?: (text: string) => void;
-    onError?: (error: string) => void;
-    lastText: string;
-  }>();
-
-  constructor(url: string, token: string) {
-    this.client = new GatewayClient(url, token);
-    this.client.setEventHandler(this.handleEvent.bind(this));
-  }
-
-  async connect(): Promise<void> {
-    await this.client.connect();
-  }
-
-  disconnect(): void {
-    this.client.disconnect();
-  }
-
-  isConnected(): boolean {
-    return this.client.isConnected();
-  }
-
-  async listSessions(): Promise<ChatSession[]> {
-    const result = await this.client.request('sessions.list', {});
-    return (result?.sessions ?? []).map((s: any) => ({
-      key: s.key,
-      sessionId: s.sessionId ?? '',
-      kind: s.kind ?? 'direct',
-      updatedAt: s.updatedAt ?? 0,
-      model: s.model,
-    }));
-  }
-
-  async getHistory(sessionKey: string, limit = 200): Promise<ChatMessage[]> {
-    const result = await this.client.request('chat.history', { sessionKey, limit });
-    return (result?.messages ?? [])
-      .filter((m: any) => m.role === 'user' || m.role === 'assistant')
-      .map((m: any) => {
-        const content = Array.isArray(m.content)
-          ? m.content.filter((c: any) => c.type === 'text').map((c: any) => c.text).join('')
-          : String(m.content ?? '');
-        return {
-          role: m.role,
-          content,
-          timestamp: typeof m.timestamp === 'number'
-            ? new Date(m.timestamp).toISOString()
-            : m.timestamp ?? new Date().toISOString(),
-        };
-      });
-  }
-
-  async sendMessage(params: {
-    sessionKey: string;
-    text: string;
-    idempotencyKey: string;
-    attachments?: ChatAttachment[];
-    onDelta?: (text: string) => void;
-    onDone?: (text: string) => void;
-    onError?: (error: string) => void;
-  }): Promise<void> {
-    // Register stream callbacks BEFORE sending
-    this.streamCallbacks.set(params.idempotencyKey, {
-      onDelta: params.onDelta,
-      onDone: params.onDone,
-      onError: params.onError,
-      lastText: '',
-    });
-
-    const payload: any = {
-      sessionKey: params.sessionKey,
-      message: params.text,
-      deliver: false,
-      idempotencyKey: params.idempotencyKey,
-    };
-    if (params.attachments?.length) {
-      payload.attachments = params.attachments;
-    }
-
-    try {
-      await this.client.request('chat.send', payload);
-      // Request accepted — response comes via events
-    } catch (err) {
-      this.streamCallbacks.delete(params.idempotencyKey);
-      params.onError?.(err instanceof Error ? err.message : String(err));
-    }
-  }
-
-  async abort(sessionKey: string, runId?: string): Promise<void> {
-    await this.client.request('chat.abort', { sessionKey, runId }).catch(() => {});
-  }
-
-  private handleEvent(event: { event: string; payload: any }): void {
-    const data = event.payload;
-    if (!data || !data.sessionKey) return;
-
-    // Stream events have runId matching idempotencyKey
-    const runId = data.runId;
-    const cb = runId ? this.streamCallbacks.get(runId) : null;
-    if (!cb) return;
-
-    if (data.state === 'delta' && data.message != null) {
-      // message is accumulated text
-      const text = typeof data.message === 'string'
-        ? data.message
-        : Array.isArray(data.message)
-          ? data.message.filter((c: any) => c.type === 'text').map((c: any) => c.text).join('')
-          : '';
-      cb.lastText = text;
-      cb.onDelta?.(text);
-    } else if (data.state === 'final') {
-      this.streamCallbacks.delete(runId!);
-      cb.onDone?.(cb.lastText);
-    } else if (data.state === 'aborted') {
-      this.streamCallbacks.delete(runId!);
-      cb.onDone?.(cb.lastText); // still send whatever we have
-    } else if (data.state === 'error') {
-      this.streamCallbacks.delete(runId!);
-      const errMsg = typeof data.error === 'string' ? data.error : data.error?.message ?? 'Unknown error';
-      cb.onError?.(errMsg);
-    }
-  }
-}

package/src/openclaw/gateway-client.ts

@@ -1,131 +0,0 @@
-import WebSocket from 'ws';
-import { randomUUID } from 'crypto';
-
-interface PendingRequest {
-  resolve: (payload: any) => void;
-  reject: (err: Error) => void;
-}
-
-export type EventHandler = (event: { event: string; payload: any; seq?: number }) => void;
-
-export class GatewayClient {
-  private ws: WebSocket | null = null;
-  private pending = new Map<string, PendingRequest>();
-  private onEvent: EventHandler | null = null;
-  private connected = false;
-  private token: string;
-  private url: string;
-
-  constructor(url: string, token: string) {
-    this.url = url;
-    this.token = token;
-  }
-
-  setEventHandler(handler: EventHandler): void {
-    this.onEvent = handler;
-  }
-
-  connect(): Promise<void> {
-    return new Promise((resolve, reject) => {
-      this.ws = new WebSocket(this.url);
-
-      this.ws.on('open', () => {
-        // Wait for connect.challenge event, then authenticate
-      });
-
-      this.ws.on('message', (raw) => {
-        try {
-          const msg = JSON.parse(raw.toString());
-          this.handleMessage(msg);
-        } catch {}
-      });
-
-      this.ws.on('error', (e) => {
-        if (!this.connected) reject(e);
-      });
-
-      this.ws.on('close', () => {
-        this.connected = false;
-        this.flushPending(new Error('Connection closed'));
-      });
-
-      // Wait for connect.challenge → authenticate → resolve
-      const origHandler = this.onEvent;
-      this.onEvent = async (ev) => {
-        if (ev.event === 'connect.challenge') {
-          try {
-            await this.request('connect', {
-              auth: { token: this.token },
-              scopes: ['operator.admin'],
-              caps: [],
-            });
-            this.connected = true;
-            this.onEvent = origHandler;
-            resolve();
-          } catch (e) {
-            reject(e);
-          }
-        }
-      };
-
-      setTimeout(() => {
-        if (!this.connected) reject(new Error('Connect timeout'));
-      }, 10_000);
-    });
-  }
-
-  disconnect(): void {
-    this.ws?.close();
-    this.ws = null;
-    this.connected = false;
-    this.flushPending(new Error('Disconnected'));
-  }
-
-  isConnected(): boolean {
-    return this.connected && this.ws?.readyState === WebSocket.OPEN;
-  }
-
-  request(method: string, params: any): Promise<any> {
-    return new Promise((resolve, reject) => {
-      if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
-        return reject(new Error('Not connected'));
-      }
-
-      const id = randomUUID();
-      this.pending.set(id, { resolve, reject });
-      this.ws.send(JSON.stringify({ type: 'req', id, method, params }));
-
-      // Timeout per request
-      setTimeout(() => {
-        if (this.pending.has(id)) {
-          this.pending.delete(id);
-          reject(new Error(`Request timeout: ${method}`));
-        }
-      }, 120_000);
-    });
-  }
-
-  private handleMessage(msg: any): void {
-    if (msg.type === 'event') {
-      this.onEvent?.(msg);
-      return;
-    }
-    if (msg.type === 'res') {
-      const req = this.pending.get(msg.id);
-      if (!req) return;
-      this.pending.delete(msg.id);
-      if (msg.ok) {
-        req.resolve(msg.payload);
-      } else {
-        req.reject(new Error(msg.error?.message ?? 'Request failed'));
-      }
-    }
-  }
-
-  private flushPending(err: Error): void {
-    for (const [, req] of this.pending) {
-      req.reject(err);
-    }
-    this.pending.clear();
-  }
-}

package/src/openclaw/index.ts

@@ -1,17 +0,0 @@
-export { OpenclawGatewayAdapter } from './gateway-adapter.js';
-export type { IChatProvider, ChatSession, ChatMessage, ChatAttachment } from './types.js';
-
-import { OpenclawGatewayAdapter } from './gateway-adapter.js';
-import type { IChatProvider } from './types.js';
-
-let _provider: IChatProvider | null = null;
-
-export function createChatProvider(url: string, token: string): IChatProvider & { connect(): Promise<void>; disconnect(): void } {
-  const adapter = new OpenclawGatewayAdapter(url, token);
-  _provider = adapter;
-  return adapter;
-}
-
-export function getChatProvider(): IChatProvider | null {
-  return _provider;
-}

package/src/openclaw/types.ts

@@ -1,41 +0,0 @@
-export interface ChatSession {
-  key: string;
-  sessionId: string;
-  kind: string;
-  updatedAt: number;
-  model?: string;
-}
-
-export interface ChatMessage {
-  role: 'user' | 'assistant';
-  content: string;        // normalized to plain text
-  timestamp: string;      // ISO 8601
-}
-
-export interface ChatAttachment {
-  type: 'image';
-  mimeType: string;
-  content: string;        // base64
-}
-
-export interface IChatProvider {
-  listSessions(): Promise<ChatSession[]>;
-  getHistory(sessionKey: string, limit?: number): Promise<ChatMessage[]>;
-
-  /**
-   * Send message. Returns after the agent finishes (full response).
-   * Calls onDelta with accumulated text during streaming.
-   * Calls onDone when agent response is complete.
-   */
-  sendMessage(params: {
-    sessionKey: string;
-    text: string;
-    idempotencyKey: string;
-    attachments?: ChatAttachment[];
-    onDelta?: (accumulatedText: string) => void;
-    onDone?: (finalText: string) => void;
-    onError?: (error: string) => void;
-  }): Promise<void>;
-
-  abort(sessionKey: string, runId?: string): Promise<void>;
-}

package/src/platform/linux.ts

@@ -1,108 +0,0 @@
-import { exec } from 'node:child_process';
-import { writeFileSync, mkdirSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-
-export interface PlatformConfig {
-  centrifugoUrl: string;
-  agentToken: string;
-  agentId: string;
-  backendInternalUrl: string;
-}
-
-function execAsync(cmd: string): Promise<string> {
-  return new Promise((resolve, reject) => {
-    exec(cmd, (err, stdout) => {
-      if (err) reject(err);
-      else resolve(stdout.toString().trim());
-    });
-  });
-}
-
-async function which(bin: string): Promise<string> {
-  try {
-    return await execAsync(`which "${bin}"`);
-  } catch {
-    return '';
-  }
-}
-
-export async function installLinux(config: PlatformConfig): Promise<void> {
-  const home = homedir();
-  const systemdDir = join(home, '.config', 'systemd', 'user');
-  const servicePath = join(systemdDir, 'agent-controller.service');
-
-  const nodePath = process.execPath;
-  let agentControllerPath = await which('agent-controller');
-  if (!agentControllerPath) {
-    agentControllerPath = join(nodePath, '..', 'agent-controller');
-  }
-
-  mkdirSync(systemdDir, { recursive: true });
-
-  const service = `[Unit]
-Description=OpenClaw Agent Controller
-After=network.target
-
-[Service]
-Type=simple
-Restart=always
-RestartSec=10
-Environment=CENTRIFUGO_URL=${config.centrifugoUrl}
-Environment=AGENT_TOKEN=${config.agentToken}
-Environment=AGENT_ID=${config.agentId}
-Environment=BACKEND_INTERNAL_URL=${config.backendInternalUrl}
-ExecStart="${nodePath}" "${agentControllerPath}"
-
-[Install]
-WantedBy=default.target
-`;
-
-  writeFileSync(servicePath, service, 'utf8');
-  console.log(`Written: ${servicePath}`);
-
-  try {
-    await execAsync('systemctl --user daemon-reload');
-    console.log('systemd daemon reloaded.');
-    await execAsync('systemctl --user enable --now agent-controller');
-    console.log('Service enabled and started.');
-  } catch (err) {
-    console.warn('systemctl command failed:', err instanceof Error ? err.message : err);
-  }
-
-  console.log('');
-  console.log('Agent Controller installed as a systemd user service.');
-  console.log('');
-  console.log('Useful commands:');
-  console.log('  Start:     systemctl --user start agent-controller');
-  console.log('  Stop:      systemctl --user stop agent-controller');
-  console.log('  Status:    systemctl --user status agent-controller');
-  console.log('  Logs:      journalctl --user -u agent-controller -f');
-  console.log('  Uninstall: agent-controller uninstall');
-}
-
-export async function uninstallLinux(): Promise<void> {
-  try {
-    await execAsync('systemctl --user disable --now agent-controller');
-    console.log('Service disabled and stopped.');
-  } catch (err) {
-    console.warn('systemctl disable failed (may not be enabled):', err instanceof Error ? err.message : err);
-  }
-
-  const servicePath = join(homedir(), '.config', 'systemd', 'user', 'agent-controller.service');
-  const { unlinkSync, existsSync } = await import('node:fs');
-  if (existsSync(servicePath)) {
-    unlinkSync(servicePath);
-    console.log(`Removed: ${servicePath}`);
-  } else {
-    console.log(`Service file not found: ${servicePath}`);
-  }
-
-  try {
-    await execAsync('systemctl --user daemon-reload');
-  } catch {
-    // best-effort
-  }
-
-  console.log('Agent Controller uninstalled.');
-}