@openclaw-cloud/agent-controller 0.2.6 → 0.2.7

package/src/handlers/board-handler.ts

@@ -1,155 +0,0 @@
-import { exec } from 'node:child_process';
-import type { AgentApi } from '../api.js';
-import type { BoardState, BoardEvent, BoardInfo, CardDetail } from '../types.js';
-
-const OPENCLAW_TIMEOUT = 30_000;
-
-export class BoardHandler {
-  private boardState: BoardState = { state: 'idle', cardId: null };
-  private myColumnIds: string[] = [];
-  private boardId: string | null = null;
-  private workspaceId: string | null = null;
-  private api: AgentApi;
-
-  constructor(api: AgentApi) {
-    this.api = api;
-  }
-
-  async initialize(): Promise<string | null> {
-    try {
-      const data = await this.api.get('/api/agent/board') as BoardInfo;
-      this.boardId = data.board.id;
-      this.workspaceId = data.board.workspaceId;
-      this.myColumnIds = data.board.myColumnIds;
-      console.log(`Board initialized: ${this.boardId} (workspace: ${this.workspaceId}), watching ${this.myColumnIds.length} column(s)`);
-
-      // Backfill: check for existing unassigned cards in my columns
-      await this.checkQueue(data);
-      // Return workspaceId for channel subscription (board:<workspaceId>)
-      return this.workspaceId;
-    } catch (err) {
-      console.error('Board initialization failed:', err instanceof Error ? err.message : err);
-      return null;
-    }
-  }
-
-  async onBoardEvent(event: BoardEvent): Promise<void> {
-    switch (event.event) {
-      case 'card:entered':
-        if (!event.columnId || !this.myColumnIds.includes(event.columnId)) return;
-        if (this.boardState.state === 'working') return;
-        await this.tryClaimCard(event.cardId);
-        break;
-      case 'card:claimed':
-      case 'card:moved':
-      case 'card:commented':
-        // Info only, ignore
-        break;
-    }
-  }
-
-  async tryClaimCard(cardId: string): Promise<void> {
-    try {
-      const res = await this.api.post(`/api/agent/board/cards/${cardId}/claim`);
-      if (res.ok) {
-        this.boardState = { state: 'working', cardId };
-        console.log(`Claimed card: ${cardId}`);
-        await this.startTask(cardId);
-      } else if (res.status === 409) {
-        console.log(`Card ${cardId} already claimed or agent busy, skipping`);
-      } else {
-        const body = await res.text().catch(() => '');
-        console.error(`Claim card ${cardId} failed (HTTP ${res.status}): ${body}`);
-      }
-    } catch (err) {
-      console.error('tryClaimCard error:', err instanceof Error ? err.message : err);
-    }
-  }
-
-  async startTask(cardId: string): Promise<void> {
-    try {
-      const data = await this.api.get(`/api/agent/board/cards/${cardId}`) as CardDetail;
-      const card = data.card;
-      const message = [
-        `New task from board: ${card.title}`,
-        card.description ? `Description: ${card.description}` : null,
-        card.priority ? `Priority: ${card.priority}` : null,
-        '',
-        'Instructions:',
-        '- Complete the task described above.',
-        '- Post progress and results as comments using: POST /api/agent/board/cards/' + cardId + '/comments',
-        '- When done, move the card forward using: POST /api/agent/board/cards/' + cardId + '/move',
-      ].filter(Boolean).join('\n');
-
-      await this.execOpenclaw(message);
-    } catch (err) {
-      console.error(`startTask(${cardId}) error:`, err instanceof Error ? err.message : err);
-    }
-  }
-
-  completeTask(cardId: string): void {
-    console.log(`Task completed: ${cardId}`);
-    this.boardState = { state: 'idle', cardId: null };
-    this.checkQueue().catch((err) => {
-      console.error('checkQueue after completeTask error:', err instanceof Error ? err.message : err);
-    });
-  }
-
-  async checkQueue(existingData?: BoardInfo): Promise<void> {
-    try {
-      const data = existingData ?? (await this.api.get('/api/agent/board') as BoardInfo);
-      const candidates: Array<{ id: string; priority?: string; createdAt?: string }> = [];
-
-      for (const col of data.board.columns) {
-        if (!this.myColumnIds.includes(col.id)) continue;
-        for (const card of col.cards) {
-          if (!card.assignedAgentId) {
-            candidates.push(card);
-          }
-        }
-      }
-
-      if (candidates.length === 0) return;
-
-      // Sort by priority (high > medium > low) then by creation date (oldest first)
-      const priorityOrder: Record<string, number> = { critical: 0, high: 1, medium: 2, low: 3 };
-      candidates.sort((a, b) => {
-        const pa = priorityOrder[a.priority ?? 'medium'] ?? 2;
-        const pb = priorityOrder[b.priority ?? 'medium'] ?? 2;
-        if (pa !== pb) return pa - pb;
-        return (a.createdAt ?? '').localeCompare(b.createdAt ?? '');
-      });
-
-      console.log(`Queue: ${candidates.length} unassigned card(s) in my columns, trying first`);
-      await this.tryClaimCard(candidates[0].id);
-    } catch (err) {
-      console.error('checkQueue error:', err instanceof Error ? err.message : err);
-    }
-  }
-
-  getBoardStatus(): BoardState {
-    return this.boardState;
-  }
-
-  getBoardId(): string | null {
-    return this.boardId;
-  }
-
-  private execOpenclaw(message: string): Promise<void> {
-    return new Promise((resolve) => {
-      const escaped = message.replace(/'/g, "'\\''");
-      exec(
-        `openclaw system event --text '${escaped}' --mode now`,
-        { timeout: OPENCLAW_TIMEOUT },
-        (error, stdout, stderr) => {
-          if (error) {
-            console.error('openclaw system event failed:', stderr.toString() || error.message);
-          } else {
-            console.log('openclaw system event sent');
-          }
-          resolve();
-        },
-      );
-    });
-  }
-}

package/src/handlers/chat.ts

@@ -1,79 +0,0 @@
-import type { AgentCommand } from '../types.js';
-import { getChatProvider } from '../openclaw/index.js';
-
-export async function handleChatListSessions(
-  command: AgentCommand,
-  publish: (data: unknown) => Promise<void>,
-): Promise<void> {
-  const provider = getChatProvider();
-  if (!provider) {
-    await publish({ type: 'chat_sessions_response', correlationId: command.id, sessions: [], error: 'Chat provider not initialized' });
-    return;
-  }
-  try {
-    const sessions = await provider.listSessions();
-    await publish({ type: 'chat_sessions_response', correlationId: command.id, sessions });
-  } catch (err) {
-    await publish({ type: 'chat_sessions_response', correlationId: command.id, sessions: [], error: err instanceof Error ? err.message : String(err) });
-  }
-}
-
-export async function handleChatHistory(
-  command: AgentCommand,
-  publish: (data: unknown) => Promise<void>,
-): Promise<void> {
-  const { sessionKey, limit } = command.payload as { sessionKey: string; limit?: number };
-  const provider = getChatProvider();
-  if (!provider) {
-    await publish({ type: 'chat_history_response', correlationId: command.id, messages: [], error: 'Chat provider not initialized' });
-    return;
-  }
-  try {
-    const messages = await provider.getHistory(sessionKey, limit ?? 200);
-    await publish({ type: 'chat_history_response', correlationId: command.id, messages });
-  } catch (err) {
-    await publish({ type: 'chat_history_response', correlationId: command.id, messages: [], error: err instanceof Error ? err.message : String(err) });
-  }
-}
-
-export async function handleChatSend(
-  command: AgentCommand,
-  publish: (data: unknown) => Promise<void>,
-  agentId: string,
-): Promise<void> {
-  const { sessionKey, text, attachments } = command.payload as {
-    sessionKey: string;
-    text: string;
-    attachments?: Array<{ type: 'image'; mimeType: string; content: string }>;
-  };
-  const correlationId = command.id;
-
-  // Typing indicator
-  await publish({ type: 'chat_typing', agentId, state: true }).catch(() => {});
-
-  const provider = getChatProvider();
-  if (!provider) {
-    await publish({ type: 'chat_response', correlationId, sessionKey, text: '', error: 'Chat provider not initialized' });
-    return;
-  }
-
-  try {
-    await provider.sendMessage({
-      sessionKey,
-      text,
-      idempotencyKey: correlationId,
-      attachments, // base64 inline — Centrifugo limit raised to 10MB
-      onDelta: async (accumulated) => {
-        await publish({ type: 'chat_delta', correlationId, sessionKey, text: accumulated }).catch(() => {});
-      },
-      onDone: async (finalText) => {
-        await publish({ type: 'chat_response', correlationId, sessionKey, text: finalText }).catch(() => {});
-      },
-      onError: async (error) => {
-        await publish({ type: 'chat_response', correlationId, sessionKey, text: '', error }).catch(() => {});
-      },
-    });
-  } catch (err) {
-    await publish({ type: 'chat_response', correlationId, sessionKey, text: '', error: err instanceof Error ? err.message : String(err) }).catch(() => {});
-  }
-}

package/src/handlers/config.ts

@@ -1,48 +0,0 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { exec } from 'node:child_process';
-import type { AgentCommand, AgentResponse } from '../types.js';
-
-const CONFIG_DIR = '/etc/openclaw';
-
-export function handleConfig(command: AgentCommand): Promise<AgentResponse> {
-  const filename = command.payload.filename as string;
-  const content = command.payload.content as string;
-
-  if (!filename || content === undefined) {
-    return Promise.resolve({
-      id: command.id,
-      type: 'config',
-      success: false,
-      error: 'Missing "filename" or "content" in payload',
-    });
-  }
-
-  const configPath = path.join(CONFIG_DIR, path.basename(filename));
-
-  return fs.mkdir(CONFIG_DIR, { recursive: true })
-    .then(() => fs.writeFile(configPath, content, 'utf-8'))
-    .then(() => {
-      return new Promise<AgentResponse>((resolve) => {
-        exec('openclaw gateway restart', { timeout: 30_000 }, (error, stdout, stderr) => {
-          resolve({
-            id: command.id,
-            type: 'config',
-            success: !error,
-            data: {
-              path: configPath,
-              stdout: stdout.toString(),
-              stderr: stderr.toString(),
-            },
-            ...(error ? { error: error.message } : {}),
-          });
-        });
-      });
-    })
-    .catch((err) => ({
-      id: command.id,
-      type: 'config',
-      success: false,
-      error: err instanceof Error ? err.message : String(err),
-    }));
-}

package/src/handlers/deploy.ts

@@ -1,32 +0,0 @@
-import { exec } from 'node:child_process';
-import type { AgentCommand, AgentResponse } from '../types.js';
-
-export function handleDeploy(command: AgentCommand): Promise<AgentResponse> {
-  return new Promise((resolve) => {
-    exec('npm i -g openclaw', { timeout: 120_000 }, (installErr, installOut, installStderr) => {
-      if (installErr) {
-        resolve({
-          id: command.id,
-          type: 'deploy',
-          success: false,
-          data: { stdout: installOut.toString(), stderr: installStderr.toString() },
-          error: `Install failed: ${installErr.message}`,
-        });
-        return;
-      }
-
-      exec('openclaw gateway restart', { timeout: 30_000 }, (restartErr, restartOut, restartStderr) => {
-        resolve({
-          id: command.id,
-          type: 'deploy',
-          success: !restartErr,
-          data: {
-            install: { stdout: installOut.toString(), stderr: installStderr.toString() },
-            restart: { stdout: restartOut.toString(), stderr: restartStderr.toString() },
-          },
-          ...(restartErr ? { error: `Restart failed: ${restartErr.message}` } : {}),
-        });
-      });
-    });
-  });
-}

package/src/handlers/exec.ts

@@ -1,32 +0,0 @@
-import { exec } from 'node:child_process';
-import type { AgentCommand, AgentResponse } from '../types.js';
-
-const EXEC_TIMEOUT = 60_000;
-
-export function handleExec(command: AgentCommand): Promise<AgentResponse> {
-  const cmd = command.payload.command as string;
-  if (!cmd) {
-    return Promise.resolve({
-      id: command.id,
-      type: 'exec',
-      success: false,
-      error: 'Missing "command" in payload',
-    });
-  }
-
-  return new Promise((resolve) => {
-    exec(cmd, { timeout: EXEC_TIMEOUT }, (error, stdout, stderr) => {
-      resolve({
-        id: command.id,
-        type: 'exec',
-        success: !error,
-        data: {
-          exitCode: error ? (error as NodeJS.ErrnoException & { code?: number }).code ?? 1 : 0,
-          stdout: stdout.toString(),
-          stderr: stderr.toString(),
-        },
-        ...(error ? { error: error.message } : {}),
-      });
-    });
-  });
-}

package/src/handlers/file-delete.ts

@@ -1,46 +0,0 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import type { AgentCommand, AgentResponse } from '../types.js';
-
-const WORKSPACE_DIR = process.env.WORKSPACE_DIR ?? '/etc/openclaw/workspace';
-
-export async function handleFileDelete(command: AgentCommand): Promise<AgentResponse> {
-  const filePath = command.payload.path as string;
-
-  if (!filePath) {
-    return {
-      id: command.id,
-      type: 'file_delete',
-      success: false,
-      error: 'Missing "path" in payload',
-    };
-  }
-
-  if (filePath.includes('..') || filePath.startsWith('/')) {
-    return {
-      id: command.id,
-      type: 'file_delete',
-      success: false,
-      error: 'Invalid path: must not contain ".." or start with "/"',
-    };
-  }
-
-  const resolvedPath = path.join(WORKSPACE_DIR, filePath);
-
-  try {
-    await fs.unlink(resolvedPath);
-    return {
-      id: command.id,
-      type: 'file_delete',
-      success: true,
-      data: { path: resolvedPath },
-    };
-  } catch (err) {
-    return {
-      id: command.id,
-      type: 'file_delete',
-      success: false,
-      error: err instanceof Error ? err.message : String(err),
-    };
-  }
-}

package/src/handlers/file-write.ts

@@ -1,65 +0,0 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import type { AgentCommand, AgentResponse } from '../types.js';
-
-const WORKSPACE_DIR = process.env.WORKSPACE_DIR ?? '/etc/openclaw/workspace';
-
-export async function handleFileWrite(command: AgentCommand): Promise<AgentResponse> {
-  const filePath = command.payload.path as string;
-  const content = command.payload.content;
-  const overwrite = (command.payload.overwrite as boolean | undefined) ?? true;
-
-  if (!filePath || content === undefined) {
-    return {
-      id: command.id,
-      type: 'file_write',
-      success: false,
-      error: 'Missing "path" or "content" in payload',
-    };
-  }
-
-  if (filePath.includes('..') || filePath.startsWith('/')) {
-    return {
-      id: command.id,
-      type: 'file_write',
-      success: false,
-      error: 'Invalid path: must not contain ".." or start with "/"',
-    };
-  }
-
-  const resolvedPath = path.join(WORKSPACE_DIR, filePath);
-
-  try {
-    if (!overwrite) {
-      try {
-        await fs.access(resolvedPath);
-        // File exists — skip
-        return {
-          id: command.id,
-          type: 'file_write',
-          success: true,
-          data: { path: resolvedPath, written: false, skipped: true },
-        };
-      } catch {
-        // File does not exist — proceed with write
-      }
-    }
-
-    await fs.mkdir(path.dirname(resolvedPath), { recursive: true });
-    await fs.writeFile(resolvedPath, content as string, 'utf-8');
-
-    return {
-      id: command.id,
-      type: 'file_write',
-      success: true,
-      data: { path: resolvedPath, written: true },
-    };
-  } catch (err) {
-    return {
-      id: command.id,
-      type: 'file_write',
-      success: false,
-      error: err instanceof Error ? err.message : String(err),
-    };
-  }
-}

package/src/handlers/knowledge-sync.ts

@@ -1,53 +0,0 @@
-import fs from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-import type { AgentCommand, AgentResponse } from '../types.js';
-
-function getWorkspaceDir(): string {
-  const stateDir = process.env.OPENCLAW_STATE_DIR?.trim() ?? path.join(os.homedir(), '.openclaw');
-  return path.join(stateDir, 'workspace');
-}
-
-export async function handleKnowledgeSync(command: AgentCommand): Promise<AgentResponse> {
-  const requestedPaths = command.payload.paths as string[];
-  if (!Array.isArray(requestedPaths)) {
-    return { id: command.id, type: 'knowledge_sync', success: false, error: 'Missing "paths" in payload' };
-  }
-
-  const workspaceDir = getWorkspaceDir();
-  const resolvedPaths: string[] = [];
-
-  for (const p of requestedPaths) {
-    if (p.endsWith('/')) {
-      // Directory — scan for .md files
-      const dir = path.join(workspaceDir, p);
-      try {
-        const entries = await fs.readdir(dir);
-        for (const entry of entries) {
-          if (entry.endsWith('.md')) resolvedPaths.push(path.join(p, entry));
-        }
-      } catch {
-        // Directory doesn't exist — skip
-      }
-    } else {
-      resolvedPaths.push(p);
-    }
-  }
-
-  const files: { path: string; content: string }[] = [];
-  for (const filePath of resolvedPaths) {
-    try {
-      const content = await fs.readFile(path.join(workspaceDir, filePath), 'utf-8');
-      files.push({ path: filePath, content });
-    } catch {
-      // File doesn't exist or unreadable — skip
-    }
-  }
-
-  return {
-    id: command.id,
-    type: 'knowledge_sync',
-    success: true,
-    data: { files },
-  };
-}

package/src/handlers/onboarding.ts

@@ -1,19 +0,0 @@
-import { exec } from 'node:child_process';
-import type { AgentCommand, AgentResponse } from '../types.js';
-
-export function handleOnboardingComplete(command: AgentCommand): Promise<AgentResponse> {
-  return new Promise((resolve) => {
-    exec('openclaw gateway restart', { timeout: 30_000 }, (error, stdout, stderr) => {
-      resolve({
-        id: command.id,
-        type: 'onboarding_complete',
-        success: !error,
-        data: {
-          stdout: stdout.toString(),
-          stderr: stderr.toString(),
-        },
-        ...(error ? { error: error.message } : {}),
-      });
-    });
-  });
-}

package/src/handlers/package-install.ts

@@ -1,69 +0,0 @@
-import { exec } from 'node:child_process';
-import type { AgentCommand, AgentResponse } from '../types.js';
-
-const INSTALL_TIMEOUT_MS = 300_000; // 5 minutes total
-
-function execPackage(cmd: string, timeoutMs: number): Promise<void> {
-  return new Promise((resolve, reject) => {
-    exec(cmd, { timeout: timeoutMs }, (error) => {
-      if (error) reject(error);
-      else resolve();
-    });
-  });
-}
-
-export async function handlePackageInstall(command: AgentCommand): Promise<AgentResponse> {
-  const packages = command.payload.packages as {
-    apt?: string[];
-    npm?: string[];
-    pip?: string[];
-  } | undefined;
-
-  const apt = packages?.apt ?? [];
-  const npm = packages?.npm ?? [];
-  const pip = packages?.pip ?? [];
-
-  if (apt.length === 0 && npm.length === 0 && pip.length === 0) {
-    return {
-      id: command.id,
-      type: 'package_install',
-      success: true,
-      data: { installed: { apt: [], npm: [], pip: [] }, errors: [] },
-    };
-  }
-
-  const installed: { apt: string[]; npm: string[]; pip: string[] } = { apt: [], npm: [], pip: [] };
-  const errors: Array<{ name: string; error: string }> = [];
-  const deadline = Date.now() + INSTALL_TIMEOUT_MS;
-
-  async function tryInstall(pkg: string, cmd: string, type: 'apt' | 'npm' | 'pip'): Promise<void> {
-    const remaining = deadline - Date.now();
-    if (remaining <= 0) {
-      errors.push({ name: pkg, error: 'Install timeout exceeded' });
-      return;
-    }
-    try {
-      await execPackage(cmd, remaining);
-      installed[type].push(pkg);
-    } catch (err) {
-      errors.push({ name: pkg, error: err instanceof Error ? err.message : String(err) });
-    }
-  }
-
-  for (const pkg of apt) {
-    await tryInstall(pkg, `apt-get install -y ${pkg}`, 'apt');
-  }
-  for (const pkg of npm) {
-    await tryInstall(pkg, `npm install -g ${pkg}`, 'npm');
-  }
-  for (const pkg of pip) {
-    await tryInstall(pkg, `pip install ${pkg}`, 'pip');
-  }
-
-  return {
-    id: command.id,
-    type: 'package_install',
-    success: errors.length === 0,
-    data: { installed, errors },
-  };
-}

package/src/handlers/pair.ts

@@ -1,26 +0,0 @@
-import type { AgentCommand, AgentResponse } from '../types.js';
-
-export function handlePair(command: AgentCommand): Promise<AgentResponse> {
-  const pairToken = command.payload.token as string;
-  const targetId = command.payload.targetId as string;
-
-  if (!pairToken || !targetId) {
-    return Promise.resolve({
-      id: command.id,
-      type: 'pair',
-      success: false,
-      error: 'Missing "token" or "targetId" in payload',
-    });
-  }
-
-  return Promise.resolve({
-    id: command.id,
-    type: 'pair',
-    success: true,
-    data: {
-      paired: true,
-      targetId,
-      agentId: process.env.AGENT_ID,
-    },
-  });
-}

package/src/handlers/restart.ts

@@ -1,19 +0,0 @@
-import { exec } from 'node:child_process';
-import type { AgentCommand, AgentResponse } from '../types.js';
-
-export function handleRestart(command: AgentCommand): Promise<AgentResponse> {
-  return new Promise((resolve) => {
-    exec('openclaw gateway restart', { timeout: 30_000 }, (error, stdout, stderr) => {
-      resolve({
-        id: command.id,
-        type: 'restart',
-        success: !error,
-        data: {
-          stdout: stdout.toString(),
-          stderr: stderr.toString(),
-        },
-        ...(error ? { error: error.message } : {}),
-      });
-    });
-  });
-}

package/src/handlers/stop.ts

@@ -1,17 +0,0 @@
-import type { AgentCommand, AgentResponse } from '../types.js';
-
-export function handleStop(command: AgentCommand): Promise<AgentResponse> {
-  const response: AgentResponse = {
-    id: command.id,
-    type: 'stop',
-    success: true,
-    data: { message: 'Shutting down gracefully' },
-  };
-
-  setTimeout(() => {
-    console.log('Agent stopping gracefully...');
-    process.exit(0);
-  }, 500);
-
-  return Promise.resolve(response);
-}