@openclaw-cloud/agent-controller 0.1.0

package/Dockerfile

@@ -0,0 +1,9 @@
+# Agent Controller — standalone build image
+FROM node:22-alpine AS build
+
+WORKDIR /app
+COPY package.json package-lock.json ./
+RUN npm ci --omit=dev
+COPY dist/ dist/
+COPY bin/ bin/
+RUN chmod +x bin/agent-controller.js

package/__tests__/backup.test.ts

@@ -0,0 +1,145 @@
+import { handleBackup } from '../src/handlers/backup';
+import type { AgentCommand } from '../src/types';
+import childProcess from 'node:child_process';
+import fs from 'node:fs/promises';
+
+jest.mock('node:child_process');
+jest.mock('node:fs/promises');
+
+const mockExec = childProcess.exec as unknown as jest.Mock;
+const mockStat = fs.stat as jest.Mock;
+const mockReadFile = fs.readFile as jest.Mock;
+const mockUnlink = fs.unlink as jest.Mock;
+
+function fakeExecSuccess() {
+  mockExec.mockImplementation((_cmd: string, _opts: unknown, cb: Function) => {
+    cb(null, Buffer.from(''), Buffer.from(''));
+  });
+}
+
+function fakeExecError(message: string, stderr = '') {
+  mockExec.mockImplementation((_cmd: string, _opts: unknown, cb: Function) => {
+    cb(new Error(message), Buffer.from(''), Buffer.from(stderr));
+  });
+}
+
+const mockFetch = jest.fn() as jest.Mock;
+(globalThis as any).fetch = mockFetch;
+
+describe('handleBackup', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockUnlink.mockResolvedValue(undefined);
+  });
+
+  it('rejects missing uploadUrl', async () => {
+    const cmd: AgentCommand = { id: '1', type: 'backup', payload: {} };
+    const res = await handleBackup(cmd);
+    expect(res.success).toBe(false);
+    expect(res.error).toContain('Missing "uploadUrl"');
+  });
+
+  it('creates tar, uploads, cleans up on success', async () => {
+    fakeExecSuccess();
+    mockStat.mockResolvedValue({ size: 1024 });
+    mockReadFile.mockResolvedValue(Buffer.from('fake-archive'));
+    mockFetch.mockResolvedValue({ ok: true, status: 200, statusText: 'OK' });
+
+    const cmd: AgentCommand = {
+      id: '2',
+      type: 'backup',
+      payload: { uploadUrl: 'https://backend.test/upload' },
+    };
+    const res = await handleBackup(cmd);
+
+    expect(res.success).toBe(true);
+    expect(res.data?.size).toBe(1024);
+    expect(res.data?.filename).toMatch(/^backup-\d+\.tar\.gz$/);
+
+    // verify tar command
+    expect(mockExec).toHaveBeenCalledWith(
+      expect.stringContaining('tar -czf /tmp/backup-'),
+      expect.any(Object),
+      expect.any(Function),
+    );
+
+    // verify upload
+    expect(mockFetch).toHaveBeenCalledWith(
+      'https://backend.test/upload',
+      expect.objectContaining({ method: 'POST' }),
+    );
+
+    // verify cleanup
+    expect(mockUnlink).toHaveBeenCalledWith(expect.stringContaining('/tmp/backup-'));
+  });
+
+  it('returns error when tar fails', async () => {
+    fakeExecError('tar failed', 'No such file or directory');
+
+    const cmd: AgentCommand = {
+      id: '3',
+      type: 'backup',
+      payload: { uploadUrl: 'https://backend.test/upload' },
+    };
+    const res = await handleBackup(cmd);
+
+    expect(res.success).toBe(false);
+    expect(res.error).toContain('tar failed');
+    expect(mockUnlink).toHaveBeenCalled();
+  });
+
+  it('returns error when upload fails', async () => {
+    fakeExecSuccess();
+    mockStat.mockResolvedValue({ size: 512 });
+    mockReadFile.mockResolvedValue(Buffer.from('fake'));
+    mockFetch.mockResolvedValue({ ok: false, status: 500, statusText: 'Internal Server Error' });
+
+    const cmd: AgentCommand = {
+      id: '4',
+      type: 'backup',
+      payload: { uploadUrl: 'https://backend.test/upload' },
+    };
+    const res = await handleBackup(cmd);
+
+    expect(res.success).toBe(false);
+    expect(res.error).toContain('Upload failed');
+    expect(res.error).toContain('500');
+    expect(mockUnlink).toHaveBeenCalled();
+  });
+
+  it('returns error when fetch throws (network error)', async () => {
+    fakeExecSuccess();
+    mockStat.mockResolvedValue({ size: 256 });
+    mockReadFile.mockResolvedValue(Buffer.from('fake'));
+    mockFetch.mockRejectedValue(new Error('network error'));
+
+    const cmd: AgentCommand = {
+      id: '5',
+      type: 'backup',
+      payload: { uploadUrl: 'https://backend.test/upload' },
+    };
+    const res = await handleBackup(cmd);
+
+    expect(res.success).toBe(false);
+    expect(res.error).toContain('network error');
+    expect(mockUnlink).toHaveBeenCalled();
+  });
+
+  it('cleans up even if unlink fails', async () => {
+    fakeExecSuccess();
+    mockStat.mockResolvedValue({ size: 100 });
+    mockReadFile.mockResolvedValue(Buffer.from('fake'));
+    mockFetch.mockResolvedValue({ ok: true, status: 200, statusText: 'OK' });
+    mockUnlink.mockRejectedValue(new Error('ENOENT'));
+
+    const cmd: AgentCommand = {
+      id: '6',
+      type: 'backup',
+      payload: { uploadUrl: 'https://backend.test/upload' },
+    };
+    const res = await handleBackup(cmd);
+
+    // should still succeed despite cleanup error
+    expect(res.success).toBe(true);
+  });
+});

package/__tests__/connection.test.ts

@@ -0,0 +1,111 @@
+import { Centrifuge } from 'centrifuge';
+
+jest.mock('centrifuge');
+jest.mock('ws', () => jest.fn());
+
+const MockCentrifuge = Centrifuge as jest.MockedClass<typeof Centrifuge>;
+
+// Mock subscription instance
+function createMockSubscription(channel: string) {
+  const handlers: Record<string, Function> = {};
+  return {
+    on: jest.fn((event: string, cb: Function) => { handlers[event] = cb; }),
+    subscribe: jest.fn(),
+    channel,
+    _handlers: handlers,
+  };
+}
+
+function createMockClient(mockSubs: ReturnType<typeof createMockSubscription>[]) {
+  let subIndex = 0;
+  const clientHandlers: Record<string, Function> = {};
+  return {
+    on: jest.fn((event: string, cb: Function) => { clientHandlers[event] = cb; }),
+    newSubscription: jest.fn(() => mockSubs[subIndex++]),
+    connect: jest.fn(),
+    disconnect: jest.fn(),
+    publish: jest.fn().mockResolvedValue(undefined),
+    _handlers: clientHandlers,
+  };
+}
+
+beforeEach(() => {
+  jest.clearAllMocks();
+});
+
+describe('createConnection', () => {
+  it('subscribes to agent: command channel only', async () => {
+    const commandSub = createMockSubscription('agent:test-1');
+    const mockClient = createMockClient([commandSub]);
+    MockCentrifuge.mockImplementation(() => mockClient as any);
+
+    const { createConnection } = await import('../src/connection');
+
+    const result = createConnection({
+      url: 'ws://localhost:8000/connection/websocket',
+      token: 'test-token',
+      agentId: 'test-1',
+    });
+
+    expect(MockCentrifuge).toHaveBeenCalledWith(
+      'ws://localhost:8000/connection/websocket',
+      expect.objectContaining({ token: 'test-token' })
+    );
+    expect(mockClient.newSubscription).toHaveBeenCalledWith('agent:test-1');
+    expect(mockClient.newSubscription).toHaveBeenCalledTimes(1);
+    expect(commandSub.subscribe).toHaveBeenCalled();
+    expect(mockClient.connect).toHaveBeenCalled();
+    expect(commandSub.on).toHaveBeenCalledWith('publication', expect.any(Function));
+  });
+
+  it('routes exec command to handler', async () => {
+    const commandSub = createMockSubscription('agent:test-1');
+    const mockClient = createMockClient([commandSub]);
+    MockCentrifuge.mockImplementation(() => mockClient as any);
+
+    jest.mock('node:child_process', () => ({
+      exec: jest.fn((_cmd: string, _opts: unknown, cb: Function) => {
+        cb(null, Buffer.from('output'), Buffer.from(''));
+      }),
+    }));
+
+    const { createConnection } = await import('../src/connection');
+    createConnection({ url: 'ws://localhost:8000/connection/websocket', token: 'tok', agentId: 'test-1' });
+
+    // Simulate a publication on the command channel
+    const publicationHandler = commandSub._handlers['publication'];
+    expect(publicationHandler).toBeDefined();
+
+    await publicationHandler({
+      data: { id: 'cmd-1', type: 'exec', payload: { command: 'echo hi' } },
+      channel: 'agent:test-1',
+    });
+
+    // Should have published a response to the agent channel
+    expect(mockClient.publish).toHaveBeenCalledWith(
+      'agent:test-1',
+      expect.objectContaining({ id: 'cmd-1', type: 'exec' })
+    );
+  });
+
+  it('handles unknown command types gracefully', async () => {
+    const commandSub = createMockSubscription('agent:test-1');
+    const mockClient = createMockClient([commandSub]);
+    MockCentrifuge.mockImplementation(() => mockClient as any);
+
+    const consoleSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
+
+    const { createConnection } = await import('../src/connection');
+    createConnection({ url: 'ws://localhost:8000/connection/websocket', token: 'tok', agentId: 'test-1' });
+
+    const publicationHandler = commandSub._handlers['publication'];
+    await publicationHandler({
+      data: { id: 'cmd-2', type: 'unknown_cmd', payload: {} },
+      channel: 'agent:test-1',
+    });
+
+    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Unknown command type'));
+    expect(mockClient.publish).not.toHaveBeenCalled();
+    consoleSpy.mockRestore();
+  });
+});

package/__tests__/handlers.test.ts

@@ -0,0 +1,150 @@
+import { handleExec } from '../src/handlers/exec';
+import { handleRestart } from '../src/handlers/restart';
+import { handleDeploy } from '../src/handlers/deploy';
+import { handleConfig } from '../src/handlers/config';
+import { handlePair } from '../src/handlers/pair';
+import { handleStop } from '../src/handlers/stop';
+import type { AgentCommand } from '../src/types';
+import childProcess from 'node:child_process';
+import fs from 'node:fs/promises';
+
+jest.mock('node:child_process');
+jest.mock('node:fs/promises');
+
+const mockExec = childProcess.exec as unknown as jest.Mock;
+
+function fakeExec(error: Error | null, stdout: string, stderr: string) {
+  mockExec.mockImplementation((_cmd: string, _opts: unknown, cb: Function) => {
+    cb(error, Buffer.from(stdout), Buffer.from(stderr));
+  });
+}
+
+describe('handleExec', () => {
+  beforeEach(() => jest.clearAllMocks());
+
+  it('executes a command and returns stdout', async () => {
+    fakeExec(null, 'hello\n', '');
+    const cmd: AgentCommand = { id: '1', type: 'exec', payload: { command: 'echo hello' } };
+    const res = await handleExec(cmd);
+    expect(res.success).toBe(true);
+    expect(res.data?.stdout).toBe('hello\n');
+    expect(res.data?.exitCode).toBe(0);
+  });
+
+  it('returns error when command fails', async () => {
+    const err = new Error('command failed');
+    (err as any).code = 127;
+    fakeExec(err, '', 'not found');
+    const cmd: AgentCommand = { id: '2', type: 'exec', payload: { command: 'bad' } };
+    const res = await handleExec(cmd);
+    expect(res.success).toBe(false);
+    expect(res.error).toBe('command failed');
+  });
+
+  it('rejects missing command payload', async () => {
+    const cmd: AgentCommand = { id: '3', type: 'exec', payload: {} };
+    const res = await handleExec(cmd);
+    expect(res.success).toBe(false);
+    expect(res.error).toContain('Missing');
+  });
+});
+
+describe('handleRestart', () => {
+  beforeEach(() => jest.clearAllMocks());
+
+  it('calls openclaw gateway restart', async () => {
+    fakeExec(null, 'restarted', '');
+    const cmd: AgentCommand = { id: '4', type: 'restart', payload: {} };
+    const res = await handleRestart(cmd);
+    expect(res.success).toBe(true);
+    expect(mockExec).toHaveBeenCalledWith('openclaw gateway restart', expect.any(Object), expect.any(Function));
+  });
+
+  it('returns error on restart failure', async () => {
+    fakeExec(new Error('restart failed'), '', 'err');
+    const cmd: AgentCommand = { id: '5', type: 'restart', payload: {} };
+    const res = await handleRestart(cmd);
+    expect(res.success).toBe(false);
+  });
+});
+
+describe('handleDeploy', () => {
+  beforeEach(() => jest.clearAllMocks());
+
+  it('installs and restarts on success', async () => {
+    let callCount = 0;
+    mockExec.mockImplementation((_cmd: string, _opts: unknown, cb: Function) => {
+      callCount++;
+      cb(null, Buffer.from(`step${callCount}`), Buffer.from(''));
+    });
+    const cmd: AgentCommand = { id: '6', type: 'deploy', payload: {} };
+    const res = await handleDeploy(cmd);
+    expect(res.success).toBe(true);
+    expect(mockExec).toHaveBeenCalledTimes(2);
+  });
+
+  it('fails if install fails', async () => {
+    fakeExec(new Error('npm error'), '', 'err');
+    const cmd: AgentCommand = { id: '7', type: 'deploy', payload: {} };
+    const res = await handleDeploy(cmd);
+    expect(res.success).toBe(false);
+    expect(res.error).toContain('Install failed');
+  });
+});
+
+describe('handleConfig', () => {
+  beforeEach(() => jest.clearAllMocks());
+
+  it('writes config and restarts', async () => {
+    (fs.mkdir as jest.Mock).mockResolvedValue(undefined);
+    (fs.writeFile as jest.Mock).mockResolvedValue(undefined);
+    fakeExec(null, 'ok', '');
+    const cmd: AgentCommand = { id: '8', type: 'config', payload: { filename: 'test.yml', content: 'key: val' } };
+    const res = await handleConfig(cmd);
+    expect(res.success).toBe(true);
+    expect(fs.writeFile).toHaveBeenCalled();
+  });
+
+  it('rejects missing payload', async () => {
+    const cmd: AgentCommand = { id: '9', type: 'config', payload: {} };
+    const res = await handleConfig(cmd);
+    expect(res.success).toBe(false);
+    expect(res.error).toContain('Missing');
+  });
+});
+
+describe('handlePair', () => {
+  it('returns paired response', async () => {
+    const cmd: AgentCommand = { id: '10', type: 'pair', payload: { token: 'abc', targetId: 'target-1' } };
+    const res = await handlePair(cmd);
+    expect(res.success).toBe(true);
+    expect(res.data?.paired).toBe(true);
+    expect(res.data?.targetId).toBe('target-1');
+  });
+
+  it('rejects missing pair params', async () => {
+    const cmd: AgentCommand = { id: '11', type: 'pair', payload: {} };
+    const res = await handlePair(cmd);
+    expect(res.success).toBe(false);
+  });
+});
+
+describe('handleStop', () => {
+  beforeEach(() => {
+    jest.useFakeTimers();
+    jest.spyOn(process, 'exit').mockImplementation(() => undefined as never);
+  });
+  afterEach(() => {
+    jest.useRealTimers();
+    jest.restoreAllMocks();
+  });
+
+  it('returns success and schedules shutdown', async () => {
+    const cmd: AgentCommand = { id: '12', type: 'stop', payload: {} };
+    const res = await handleStop(cmd);
+    expect(res.success).toBe(true);
+    expect(res.data?.message).toContain('gracefully');
+    jest.advanceTimersByTime(600);
+    expect(process.exit).toHaveBeenCalledWith(0);
+  });
+});

package/__tests__/heartbeat.test.ts

@@ -0,0 +1,80 @@
+import os from 'node:os';
+
+import { getMetrics, startHeartbeat } from '../src/heartbeat';
+
+describe('getMetrics', () => {
+  it('returns cpu, mem, uptime', () => {
+    const metrics = getMetrics();
+    expect(metrics).toHaveProperty('cpu');
+    expect(metrics).toHaveProperty('mem');
+    expect(metrics).toHaveProperty('uptime');
+    expect(typeof metrics.cpu).toBe('number');
+    expect(typeof metrics.mem).toBe('number');
+    expect(typeof metrics.uptime).toBe('number');
+    expect(metrics.cpu).toBeGreaterThanOrEqual(0);
+    expect(metrics.cpu).toBeLessThanOrEqual(1);
+    expect(metrics.mem).toBeGreaterThanOrEqual(0);
+    expect(metrics.mem).toBeLessThanOrEqual(1);
+  });
+});
+
+describe('startHeartbeat', () => {
+  let fetchSpy: jest.SpyInstance;
+
+  beforeEach(() => {
+    jest.useFakeTimers();
+    fetchSpy = jest.spyOn(globalThis, 'fetch').mockResolvedValue(
+      new Response('{}', { status: 200 }),
+    );
+  });
+
+  afterEach(() => {
+    jest.useRealTimers();
+    fetchSpy.mockRestore();
+  });
+
+  const opts = {
+    centrifugoInternalUrl: 'http://centrifugo-internal:9000',
+    centrifugoApiKey: 'test-key',
+    agentId: 'agent-42',
+  };
+
+  it('publishes heartbeat immediately and at intervals', () => {
+    const timer = startHeartbeat(opts);
+
+    // Immediate call
+    expect(fetchSpy).toHaveBeenCalledTimes(1);
+    expect(fetchSpy).toHaveBeenCalledWith(
+      'http://centrifugo-internal:9000/api/publish',
+      expect.objectContaining({
+        method: 'POST',
+        headers: expect.objectContaining({
+          'Authorization': 'apikey test-key',
+        }),
+      }),
+    );
+
+    // Check body contains correct channel and agent data
+    const body = JSON.parse(fetchSpy.mock.calls[0][1].body);
+    expect(body.channel).toBe('heartbeat:data');
+    expect(body.data.agentId).toBe('agent-42');
+    expect(body.data.type).toBe('heartbeat');
+
+    // After 30s
+    jest.advanceTimersByTime(30_000);
+    expect(fetchSpy).toHaveBeenCalledTimes(2);
+
+    clearInterval(timer);
+  });
+
+  it('handles publish errors gracefully', () => {
+    const consoleSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
+    fetchSpy.mockRejectedValue(new Error('network fail'));
+
+    const timer = startHeartbeat(opts);
+
+    // Should not throw
+    clearInterval(timer);
+    consoleSpy.mockRestore();
+  });
+});

package/bin/agent-controller.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+import { main } from '../dist/index.js';
+
+main();

package/dist/connection.d.ts

@@ -0,0 +1,11 @@
+import { Centrifuge, Subscription } from 'centrifuge';
+export interface ConnectionOptions {
+    url: string;
+    token: string;
+    agentId: string;
+    backendUrl?: string;
+}
+export declare function createConnection(opts: ConnectionOptions): {
+    client: Centrifuge;
+    commandSub: Subscription;
+};

package/dist/connection.js

@@ -0,0 +1,117 @@
+import { Centrifuge } from 'centrifuge';
+import WebSocket from 'ws';
+import { handleExec } from './handlers/exec.js';
+import { handleRestart } from './handlers/restart.js';
+import { handleDeploy } from './handlers/deploy.js';
+import { handleConfig } from './handlers/config.js';
+import { handlePair } from './handlers/pair.js';
+import { handleStop } from './handlers/stop.js';
+import { handleBackup } from './handlers/backup.js';
+const handlers = {
+    exec: handleExec,
+    restart: handleRestart,
+    deploy: handleDeploy,
+    config: handleConfig,
+    pair: handlePair,
+    stop: handleStop,
+    backup: handleBackup,
+};
+async function fetchCentrifugoToken(backendUrl, agentToken, agentId) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 5000);
+    try {
+        const res = await fetch(`${backendUrl}/api/internal/centrifugo-token`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${agentToken}`,
+            },
+            body: JSON.stringify({ agentId }),
+            signal: controller.signal,
+        });
+        if (!res.ok) {
+            throw new Error(`HTTP ${res.status}: ${await res.text().catch(() => '')}`);
+        }
+        const data = await res.json();
+        return data.token;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+export function createConnection(opts) {
+    const centrifugeOpts = {
+        websocket: WebSocket,
+        name: 'agent-controller',
+        minReconnectDelay: 1000,
+        maxReconnectDelay: 30000,
+    };
+    if (opts.backendUrl) {
+        // Dynamic JWT: fetch fresh token on every connect/reconnect
+        centrifugeOpts.getToken = async () => {
+            console.log('Fetching Centrifugo JWT from backend...');
+            try {
+                const token = await fetchCentrifugoToken(opts.backendUrl, opts.token, opts.agentId);
+                console.log('Got Centrifugo JWT');
+                return token;
+            }
+            catch (err) {
+                console.error('Failed to fetch Centrifugo JWT:', err instanceof Error ? err.message : err);
+                // Retry once
+                try {
+                    const token = await fetchCentrifugoToken(opts.backendUrl, opts.token, opts.agentId);
+                    console.log('Got Centrifugo JWT (retry)');
+                    return token;
+                }
+                catch (retryErr) {
+                    console.error('JWT fetch retry failed:', retryErr instanceof Error ? retryErr.message : retryErr);
+                    throw retryErr;
+                }
+            }
+        };
+    }
+    else {
+        // Fallback: use raw token (backward compat, won't work with Centrifugo JWT validation)
+        console.warn('BACKEND_INTERNAL_URL not set, using AGENT_TOKEN directly (may not work)');
+        centrifugeOpts.token = opts.token;
+    }
+    const client = new Centrifuge(opts.url, centrifugeOpts);
+    const commandChannel = `agent:${opts.agentId}`;
+    const commandSub = client.newSubscription(commandChannel);
+    commandSub.on('publication', async (ctx) => {
+        const command = ctx.data;
+        if (!command || !command.type)
+            return;
+        const handler = handlers[command.type];
+        if (!handler) {
+            console.error(`Unknown command type: ${command.type}`);
+            return;
+        }
+        try {
+            const response = await handler(command);
+            await client.publish(commandChannel, response);
+        }
+        catch (err) {
+            const errorResponse = {
+                id: command.id,
+                type: command.type,
+                success: false,
+                error: err instanceof Error ? err.message : String(err),
+            };
+            await client.publish(commandChannel, errorResponse);
+        }
+    });
+    client.on('connected', (ctx) => {
+        console.log(`Connected to Centrifugo via ${ctx.transport}`);
+    });
+    client.on('disconnected', (ctx) => {
+        console.log(`Disconnected: ${ctx.reason} (code ${ctx.code})`);
+    });
+    client.on('connecting', (ctx) => {
+        console.log(`Connecting: ${ctx.reason} (code ${ctx.code})`);
+    });
+    commandSub.subscribe();
+    client.connect();
+    return { client, commandSub };
+}
+//# sourceMappingURL=connection.js.map

package/dist/connection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection.js","sourceRoot":"","sources":["../src/connection.ts"],"names":[],"mappings":"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"}

package/dist/handlers/backup.d.ts

@@ -0,0 +1,2 @@
+import type { AgentCommand, AgentResponse } from '../types.js';
+export declare function handleBackup(command: AgentCommand): Promise<AgentResponse>;