@openclaw-cloud/agent-controller 0.2.4 → 0.2.6

package/bin/agent-controller.js

@@ -7,11 +7,16 @@ import { dirname, join } from 'node:path';
 const require = createRequire(import.meta.url);
 const pkg = require(join(dirname(fileURLToPath(import.meta.url)), '../package.json'));
 
+// Load saved env file before dispatching any command
+// This allows `agent-controller backup`, `knowledge_sync`, etc. to work without manual env vars
+const { loadEnvFile } = await import('../dist/config-file.js');
+await loadEnvFile();
+
 const [,, command] = process.argv;
 
 if (command === '--version' || command === '-v') {
   console.log(pkg.version);
-} else if (command === 'self-update') {
+} else if (command === 'self-update' || command === 'update') {
   const { selfUpdate } = await import('../dist/commands/self-update.js');
   await selfUpdate(pkg.version);
 } else if (command === 'install') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw-cloud/agent-controller",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "type": "module",
   "main": "dist/index.js",
   "bin": {

package/src/commands/install.ts

@@ -1,4 +1,5 @@
 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) => {
@@ -43,6 +44,9 @@ export async function install(): Promise<void> {
 
   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}`);

package/src/config-file.ts

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

@@ -15,6 +15,8 @@ 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;
@@ -22,21 +24,34 @@ export interface ConnectionOptions {
   agentId: string;
   backendUrl: string;
   api: AgentApi;
+  version: string;
 }
 
-const handlers: Record<string, (cmd: AgentCommand) => Promise<AgentResponse>> = {
-  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,
-};
+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();
@@ -98,6 +113,7 @@ export function createConnection(opts: ConnectionOptions): {
 
   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));

package/src/handlers/knowledge-sync.ts

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

@@ -1,11 +1,36 @@
 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()
@@ -29,6 +54,7 @@ export async function getLastMessageAt(): Promise<string | null> {
 export interface HeartbeatOptions {
   api: AgentApi;
   agentId: string;
+  version: string;
   getBoardStatus?: () => BoardState;
 }
 
@@ -54,6 +80,7 @@ async function publishHeartbeat(opts: HeartbeatOptions): Promise<void> {
     type: 'heartbeat',
     agentId: opts.agentId,
     ts: Date.now(),
+    version: opts.version,
     metrics: getMetrics(),
     ...(opts.getBoardStatus ? { boardStatus: opts.getBoardStatus() } : {}),
     lastMessageAt: await getLastMessageAt(),
@@ -72,6 +99,11 @@ async function publishHeartbeat(opts: HeartbeatOptions): Promise<void> {
 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);
 }
 

package/src/index.ts

@@ -1,3 +1,6 @@
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
 import { createConnection } from './connection.js';
 import { startHeartbeat } from './heartbeat.js';
 import { createAgentApi } from './api.js';
@@ -6,6 +9,9 @@ import { createChatProvider } from './openclaw/index.js';
 import { DEBUG } from './debug.js';
 import type { BoardEvent } from './types.js';
 
+const _require = createRequire(import.meta.url);
+const { version: CONTROLLER_VERSION } = _require(join(dirname(fileURLToPath(import.meta.url)), '../package.json')) as { version: string };
+
 function requireEnv(name: string): string {
   const value = process.env[name];
   if (!value) {
@@ -27,7 +33,7 @@ export function main(): void {
   console.log(`Backend URL: ${backendUrl} (JWT mode)`);
 
   const api = createAgentApi(backendUrl, token);
-  const { client } = createConnection({ url, token, agentId, backendUrl, api });
+  const { client } = createConnection({ url, token, agentId, backendUrl, api, version: CONTROLLER_VERSION });
 
   // Chat provider via OpenClaw Gateway WS
   const gatewayWsUrl = process.env.OPENCLAW_GATEWAY_WS || 'ws://localhost:18789';
@@ -75,6 +81,7 @@ export function main(): void {
   const heartbeatTimer = startHeartbeat({
     api,
     agentId,
+    version: CONTROLLER_VERSION,
     getBoardStatus: () => boardHandler.getBoardStatus(),
   });
 

package/src/types.ts

@@ -7,7 +7,8 @@
 export type CommandType =
   | 'exec' | 'restart' | 'deploy' | 'config' | 'pair' | 'stop' | 'backup'
   | 'chat_list_sessions' | 'chat_history' | 'chat_send'
-  | 'package_install' | 'file_write' | 'file_delete' | 'onboarding_complete';
+  | 'package_install' | 'file_write' | 'file_delete' | 'onboarding_complete'
+  | 'knowledge_sync' | 'self_update';
 
 export interface AgentCommand {
   id: string;
@@ -27,6 +28,7 @@ export interface HeartbeatPayload {
   type: 'heartbeat';
   agentId: string;
   ts: number;
+  version: string;
   metrics: {
     cpu: number;
     mem: number;