@openclaw-cloud/agent-controller 0.2.6 → 0.2.7

package/src/api.ts

@@ -1,62 +0,0 @@
-import { DEBUG, debugLog } from './debug.js';
-
-const TIMEOUT = 10_000;
-
-export interface AgentApi {
-  get(path: string): Promise<unknown>;
-  post(path: string, body?: unknown): Promise<Response>;
-  publishResponse(agentId: string, data: unknown): Promise<void>;
-  publishHeartbeat(agentId: string, payload: unknown): Promise<void>;
-}
-
-export function createAgentApi(backendUrl: string, agentToken: string): AgentApi {
-  async function request(method: string, path: string, body?: unknown): Promise<Response> {
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), TIMEOUT);
-    try {
-      debugLog('api', '→', method, path, body ? JSON.stringify(body).slice(0, 500) : '');
-      const res = await fetch(`${backendUrl}${path}`, {
-        method,
-        headers: {
-          'Content-Type': 'application/json',
-          'Authorization': `Bearer ${agentToken}`,
-        },
-        ...(body !== undefined ? { body: JSON.stringify(body) } : {}),
-        signal: controller.signal,
-      });
-      if (DEBUG) {
-        const clone = res.clone();
-        const bodyText = await clone.text().catch(() => '');
-        debugLog('api', '←', method, path, res.status, bodyText.slice(0, 1000));
-      }
-      return res;
-    } finally {
-      clearTimeout(timeout);
-    }
-  }
-
-  return {
-    async get(path: string): Promise<unknown> {
-      const res = await request('GET', path);
-      if (!res.ok) {
-        throw new Error(`GET ${path} failed: HTTP ${res.status}`);
-      }
-      return res.json();
-    },
-    async post(path: string, body?: unknown): Promise<Response> {
-      return request('POST', path, body);
-    },
-    async publishResponse(agentId: string, data: unknown): Promise<void> {
-      const res = await request('POST', '/api/internal/agent-response', { agentId, data });
-      if (!res.ok) {
-        throw new Error(`publishResponse failed: HTTP ${res.status}`);
-      }
-    },
-    async publishHeartbeat(agentId: string, payload: unknown): Promise<void> {
-      const res = await request('POST', '/api/internal/agent-heartbeat', { agentId, payload });
-      if (!res.ok) {
-        throw new Error(`publishHeartbeat failed: HTTP ${res.status}`);
-      }
-    },
-  };
-}

package/src/commands/install.ts

@@ -1,68 +0,0 @@
-import { createInterface } from 'node:readline';
-import { saveEnvFile } from '../config-file.js';
-
-async function prompt(rl: ReturnType<typeof createInterface>, question: string): Promise<string> {
-  return new Promise((resolve) => {
-    rl.question(question, (answer) => {
-      resolve(answer.trim());
-    });
-  });
-}
-
-async function getOrPrompt(
-  rl: ReturnType<typeof createInterface>,
-  envKey: string,
-  question: string,
-): Promise<string> {
-  const fromEnv = process.env[envKey];
-  if (fromEnv) {
-    const display = envKey.includes('TOKEN') ? '***' : fromEnv;
-    console.log(`  ${envKey}: ${display} (from environment)`);
-    return fromEnv;
-  }
-  return prompt(rl, question);
-}
-
-export async function install(): Promise<void> {
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
-
-  console.log('OpenClaw Agent Controller — Installation Wizard');
-  console.log('================================================');
-  console.log('');
-
-  const centrifugoUrl = await getOrPrompt(rl, 'CENTRIFUGO_URL', 'CENTRIFUGO_URL (e.g. wss://ws.openclaw-cloud.io): ');
-  const agentToken = await getOrPrompt(rl, 'AGENT_TOKEN', 'AGENT_TOKEN: ');
-  const agentId = await getOrPrompt(rl, 'AGENT_ID', 'AGENT_ID: ');
-  const backendInternalUrl = await getOrPrompt(rl, 'BACKEND_INTERNAL_URL', 'BACKEND_INTERNAL_URL (e.g. https://api.openclaw-cloud.io): ');
-
-  rl.close();
-
-  if (!centrifugoUrl || !agentToken || !agentId || !backendInternalUrl) {
-    console.error('All fields are required. Aborting.');
-    process.exit(1);
-  }
-
-  const config = { centrifugoUrl, agentToken, agentId, backendInternalUrl };
-
-  // Save env vars for future CLI usage (backup, knowledge_sync, etc.)
-  await saveEnvFile(config);
-
-  const platform = process.platform;
-  console.log('');
-  console.log(`Detected platform: ${platform}`);
-  console.log('');
-
-  if (platform === 'darwin') {
-    const { installMacOS } = await import('../platform/macos.js');
-    await installMacOS(config);
-  } else if (platform === 'linux') {
-    const { installLinux } = await import('../platform/linux.js');
-    await installLinux(config);
-  } else if (platform === 'win32') {
-    const { installWindows } = await import('../platform/windows.js');
-    await installWindows(config);
-  } else {
-    console.error(`Unsupported platform: ${platform}`);
-    process.exit(1);
-  }
-}

package/src/commands/self-update.ts

@@ -1,43 +0,0 @@
-import { exec } from 'node:child_process';
-
-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());
-    });
-  });
-}
-
-export async function selfUpdate(currentVersion: string): Promise<void> {
-  console.log(`Current version: ${currentVersion}`);
-
-  let latestVersion: string;
-  try {
-    latestVersion = await execAsync(`npm view ${PACKAGE_NAME} version`, 10_000);
-  } catch (err) {
-    console.error('Failed to fetch latest version:', err instanceof Error ? err.message : err);
-    process.exit(1);
-    return; // unreachable in production; guards test flow when process.exit is mocked
-  }
-
-  console.log(`Latest version: ${latestVersion}`);
-
-  if (currentVersion === latestVersion) {
-    console.log('Already up to date.');
-    return;
-  }
-
-  console.log(`Updating from ${currentVersion} to ${latestVersion}...`);
-  try {
-    await execAsync(`npm install -g ${PACKAGE_NAME}@latest`, 120_000);
-    console.log(`Successfully updated to ${latestVersion}. Restarting...`);
-    process.exit(0);
-    return; // unreachable in production; guards test flow when process.exit is mocked
-  } catch (err) {
-    console.error('Update failed:', err instanceof Error ? err.message : err);
-    process.exit(1);
-  }
-}

package/src/commands/uninstall.ts

@@ -1,19 +0,0 @@
-export async function uninstall(): Promise<void> {
-  const platform = process.platform;
-  console.log(`Uninstalling Agent Controller on platform: ${platform}`);
-  console.log('');
-
-  if (platform === 'darwin') {
-    const { uninstallMacOS } = await import('../platform/macos.js');
-    await uninstallMacOS();
-  } else if (platform === 'linux') {
-    const { uninstallLinux } = await import('../platform/linux.js');
-    await uninstallLinux();
-  } else if (platform === 'win32') {
-    const { uninstallWindows } = await import('../platform/windows.js');
-    await uninstallWindows();
-  } else {
-    console.error(`Unsupported platform: ${platform}`);
-    process.exit(1);
-  }
-}

package/src/config-file.ts

@@ -1,56 +0,0 @@
-import fs from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-
-const ENV_KEYS = ['CENTRIFUGO_URL', 'AGENT_TOKEN', 'AGENT_ID', 'BACKEND_INTERNAL_URL'] as const;
-
-export function getConfigDir(): string {
-  const stateDir = process.env.OPENCLAW_STATE_DIR?.trim() ?? path.join(os.homedir(), '.openclaw');
-  return path.join(stateDir, 'agent-controller');
-}
-
-export function getConfigPath(): string {
-  return path.join(getConfigDir(), 'agent.env');
-}
-
-export async function saveEnvFile(config: {
-  centrifugoUrl: string;
-  agentToken: string;
-  agentId: string;
-  backendInternalUrl: string;
-}): Promise<void> {
-  const dir = getConfigDir();
-  await fs.mkdir(dir, { recursive: true });
-
-  const content = [
-    `CENTRIFUGO_URL=${config.centrifugoUrl}`,
-    `AGENT_TOKEN=${config.agentToken}`,
-    `AGENT_ID=${config.agentId}`,
-    `BACKEND_INTERNAL_URL=${config.backendInternalUrl}`,
-  ].join('\n') + '\n';
-
-  await fs.writeFile(getConfigPath(), content, { mode: 0o600 });
-  console.log(`  Config saved to ${getConfigPath()}`);
-}
-
-export async function loadEnvFile(): Promise<void> {
-  const filePath = getConfigPath();
-  let content: string;
-  try {
-    content = await fs.readFile(filePath, 'utf-8');
-  } catch {
-    return; // No config file — skip
-  }
-
-  for (const line of content.split('\n')) {
-    const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith('#')) continue;
-    const eq = trimmed.indexOf('=');
-    if (eq === -1) continue;
-    const key = trimmed.slice(0, eq).trim();
-    const value = trimmed.slice(eq + 1).trim();
-    if (ENV_KEYS.includes(key as typeof ENV_KEYS[number]) && !process.env[key]) {
-      process.env[key] = value;
-    }
-  }
-}

package/src/connection.ts

@@ -1,203 +0,0 @@
-import { debugLog } from './debug.js';
-import type { AgentApi } from './api.js';
-import { Centrifuge, Subscription } from 'centrifuge';
-import WebSocket from 'ws';
-import type { AgentCommand, AgentResponse } from './types.js';
-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';
-import { handleChatListSessions, handleChatHistory, handleChatSend } from './handlers/chat.js';
-import { handlePackageInstall } from './handlers/package-install.js';
-import { handleFileWrite } from './handlers/file-write.js';
-import { handleFileDelete } from './handlers/file-delete.js';
-import { handleOnboardingComplete } from './handlers/onboarding.js';
-import { handleKnowledgeSync } from './handlers/knowledge-sync.js';
-import { selfUpdate } from './commands/self-update.js';
-
-export interface ConnectionOptions {
-  url: string;
-  token: string;
-  agentId: string;
-  backendUrl: string;
-  api: AgentApi;
-  version: string;
-}
-
-function buildHandlers(version: string): Record<string, (cmd: AgentCommand) => Promise<AgentResponse>> {
-  return {
-    exec: handleExec,
-    restart: handleRestart,
-    deploy: handleDeploy,
-    config: handleConfig,
-    pair: handlePair,
-    stop: handleStop,
-    backup: handleBackup,
-    package_install: handlePackageInstall,
-    file_write: handleFileWrite,
-    file_delete: handleFileDelete,
-    onboarding_complete: handleOnboardingComplete,
-    knowledge_sync: handleKnowledgeSync,
-    self_update: (cmd: AgentCommand) =>
-      selfUpdate(version)
-        .then(() => ({ id: cmd.id, type: cmd.type, success: true, data: {} }))
-        .catch((err: unknown) => ({
-          id: cmd.id,
-          type: cmd.type,
-          success: false,
-          error: err instanceof Error ? err.message : String(err),
-        })),
-  };
-}
-
-async function fetchCentrifugoToken(backendUrl: string, agentToken: string, agentId: string): Promise<string> {
-  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() as { token: string };
-    return data.token;
-  } finally {
-    clearTimeout(timeout);
-  }
-}
-
-export function createConnection(opts: ConnectionOptions): {
-  client: Centrifuge;
-  commandSub: Subscription;
-} {
-  // Dynamic JWT: fetch fresh token on every connect/reconnect
-  const getToken = async (): Promise<string> => {
-    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 before giving up — centrifuge will handle reconnect backoff
-      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;
-      }
-    }
-  };
-
-  const centrifugeOpts: Record<string, unknown> = {
-    websocket: WebSocket,
-    name: 'agent-controller',
-    getToken,
-    minReconnectDelay: 1000,
-    maxReconnectDelay: 30000,
-  };
-
-  const client = new Centrifuge(opts.url, centrifugeOpts);
-
-  const commandChannel = `agent:${opts.agentId}`;
-  const commandSub = client.newSubscription(commandChannel);
-  const handlers = buildHandlers(opts.version);
-
-  commandSub.on('publication', async (ctx) => {
-    console.log(`[WS] Received message on ${commandChannel}:`, JSON.stringify(ctx.data));
-    debugLog('connection', 'publication', commandChannel, JSON.stringify(ctx.data).slice(0, 500));
-    const command = ctx.data as AgentCommand;
-    if (!command || !command.type) {
-      console.warn('[WS] Ignoring message without type:', JSON.stringify(ctx.data));
-      return;
-    }
-
-    // Chat commands — handle before generic dispatch
-    if (command.type === 'chat_list_sessions' || command.type === 'chat_history' || command.type === 'chat_send') {
-      const publishFn = async (data: unknown): Promise<void> => { await opts.api.publishResponse(opts.agentId, data); };
-      console.log(`[WS] Handling chat command: type=${command.type} id=${command.id}`);
-      switch (command.type) {
-        case 'chat_list_sessions':
-          handleChatListSessions(command, publishFn).catch(console.error);
-          break;
-        case 'chat_history':
-          handleChatHistory(command, publishFn).catch(console.error);
-          break;
-        case 'chat_send':
-          handleChatSend(command, publishFn, opts.agentId).catch(console.error);
-          break;
-      }
-      return;
-    }
-
-    const handler = handlers[command.type];
-    if (!handler) {
-      console.error(`[WS] Unknown command type: ${command.type}`);
-      return;
-    }
-    console.log(`[WS] Handling command: type=${command.type} id=${command.id}`);
-
-    try {
-      const response = await handler(command);
-      await opts.api.publishResponse(opts.agentId, response);
-    } catch (err) {
-      const errorResponse: AgentResponse = {
-        id: command.id,
-        type: command.type,
-        success: false,
-        error: err instanceof Error ? err.message : String(err),
-      };
-      await opts.api.publishResponse(opts.agentId, errorResponse);
-    }
-  });
-
-  client.on('connected', (ctx) => {
-    console.log(`Connected to Centrifugo via ${ctx.transport}`);
-    debugLog('connection', 'connected', ctx);
-  });
-
-  client.on('disconnected', (ctx) => {
-    console.log(`Disconnected: ${ctx.reason} (code ${ctx.code})`);
-    debugLog('connection', 'disconnected', ctx);
-  });
-
-  client.on('connecting', (ctx) => {
-    console.log(`Connecting: ${ctx.reason} (code ${ctx.code})`);
-    debugLog('connection', 'connecting', ctx);
-  });
-
-  commandSub.on('subscribed', (ctx) => {
-    console.log(`[WS] Subscribed to ${commandChannel} (recovered=${ctx.wasRecovering})`);
-    debugLog('connection', 'subscribed', commandChannel, ctx);
-  });
-
-  commandSub.on('subscribing', (ctx) => {
-    console.log(`[WS] Subscribing to ${commandChannel}: ${ctx.reason} (code ${ctx.code})`);
-    debugLog('connection', 'subscribing', commandChannel, ctx);
-  });
-
-  commandSub.on('error', (ctx) => {
-    console.error(`[WS] Subscription error on ${commandChannel}:`, ctx.error);
-  });
-
-  commandSub.on('unsubscribed', (ctx) => {
-    console.log(`[WS] Unsubscribed from ${commandChannel}: ${ctx.reason} (code ${ctx.code})`);
-  });
-
-  commandSub.subscribe();
-  client.connect();
-
-  return { client, commandSub };
-}

package/src/debug.ts

@@ -1,11 +0,0 @@
-export const DEBUG = !!(process.env.AC_DEBUG || process.env.DEBUG);
-
-export function debugLog(prefix: string, ...args: unknown[]): void {
-  if (!DEBUG) return;
-  console.log(`[debug][${prefix}]`, ...args);
-}
-
-export function maskToken(token: string): string {
-  if (!token) return '';
-  return token.slice(0, 10) + '...';
-}

package/src/handlers/backup.ts

@@ -1,101 +0,0 @@
-import { exec } from 'node:child_process';
-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');
-}
-
-const BACKUP_DIR = '/tmp';
-const TAR_TIMEOUT = 120_000;
-const UPLOAD_TIMEOUT = 120_000;
-
-export function handleBackup(command: AgentCommand): Promise<AgentResponse> {
-  const uploadUrl = command.payload.uploadUrl as string;
-  const token = command.payload.token as string;
-  if (!uploadUrl) {
-    return Promise.resolve({
-      id: command.id,
-      type: 'backup',
-      success: false,
-      error: 'Missing "uploadUrl" in payload',
-    });
-  }
-
-  const timestamp = Date.now();
-  const filename = `backup-${timestamp}.tar.gz`;
-  const archivePath = path.join(BACKUP_DIR, filename);
-
-  return createArchive(archivePath)
-    .then(() => uploadArchive(archivePath, uploadUrl, token))
-    .then(async (size) => {
-      await cleanup(archivePath);
-      return {
-        id: command.id,
-        type: 'backup' as const,
-        success: true,
-        data: { size, filename },
-      };
-    })
-    .catch(async (err) => {
-      await cleanup(archivePath);
-      return {
-        id: command.id,
-        type: 'backup' as const,
-        success: false,
-        error: err instanceof Error ? err.message : String(err),
-      };
-    });
-}
-
-function createArchive(archivePath: string): Promise<void> {
-  const workspaceDir = getWorkspaceDir();
-  return new Promise((resolve, reject) => {
-    exec(
-      `tar -czf ${archivePath} -C ${path.dirname(workspaceDir)} ${path.basename(workspaceDir)}`,
-      { timeout: TAR_TIMEOUT },
-      (error, _stdout, stderr) => {
-        if (error) {
-          reject(new Error(`tar failed: ${stderr.toString() || error.message}`));
-        } else {
-          resolve();
-        }
-      },
-    );
-  });
-}
-
-async function uploadArchive(archivePath: string, uploadUrl: string, token?: string): Promise<number> {
-  const stat = await fs.stat(archivePath);
-  const fileBuffer = await fs.readFile(archivePath);
-
-  const headers: Record<string, string> = { 'Content-Type': 'application/gzip' };
-  if (token) {
-    headers['Authorization'] = `Bearer ${token}`;
-  }
-
-  const response = await fetch(uploadUrl, {
-    method: 'POST',
-    headers,
-    body: fileBuffer,
-    signal: AbortSignal.timeout(UPLOAD_TIMEOUT),
-  });
-
-  if (!response.ok) {
-    const text = await response.text().catch(() => '');
-    throw new Error(`Upload failed: ${response.status} ${response.statusText} ${text}`);
-  }
-
-  return stat.size;
-}
-
-async function cleanup(archivePath: string): Promise<void> {
-  try {
-    await fs.unlink(archivePath);
-  } catch {
-    // ignore cleanup errors
-  }
-}