@openclaw-cloud/agent-controller 0.2.5 → 0.2.7

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);
-}

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 };