@openclaw-cloud/agent-controller 0.1.4 → 0.1.5

package/src/commands/self-update.ts

@@ -0,0 +1,43 @@
+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/connection.ts

@@ -9,6 +9,9 @@ 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 { handleOnboardingComplete } from './handlers/onboarding.js';
 
 export interface ConnectionOptions {
   url: string;
@@ -25,6 +28,9 @@ const handlers: Record<string, (cmd: AgentCommand) => Promise<AgentResponse>> =
   pair: handlePair,
   stop: handleStop,
   backup: handleBackup,
+  package_install: handlePackageInstall,
+  file_write: handleFileWrite,
+  onboarding_complete: handleOnboardingComplete,
 };
 
 async function fetchCentrifugoToken(backendUrl: string, agentToken: string, agentId: string): Promise<string> {

package/src/handlers/file-write.ts

@@ -0,0 +1,65 @@
+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/onboarding.ts

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,69 @@
+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/types.ts

@@ -6,7 +6,8 @@
 
 export type CommandType =
   | 'exec' | 'restart' | 'deploy' | 'config' | 'pair' | 'stop' | 'backup'
-  | 'chat_list_sessions' | 'chat_history' | 'chat_send';
+  | 'chat_list_sessions' | 'chat_history' | 'chat_send'
+  | 'package_install' | 'file_write' | 'onboarding_complete';
 
 export interface AgentCommand {
   id: string;