rol-websocket-channel 1.0.0

package/src/admin/methods/memory.ts

@@ -0,0 +1,546 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+
+import { copyIfExists, ensureDir, pathExists } from '../lib/fs.ts';
+import { ensureInside } from '../lib/paths.ts';
+import { JsonRpcException, JSON_RPC_ERRORS } from '../jsonrpc.ts';
+import type { JsonValue, MethodHandler } from '../types.ts';
+
+const execFileAsync = promisify(execFile);
+
+interface MemoryGetParams {
+  path: string;
+}
+
+interface MemoryExportZipParams {
+  outputDir?: string;
+  zipFileName?: string;
+}
+
+interface MemoryImportZipParams {
+  zipPath: string;
+  createBackup?: boolean;
+  includePaths?: string[];
+}
+
+interface MemoryPresignedPostParams {
+  body: Record<string, JsonValue>;
+  baseUrl?: string;
+  authToken?: string;
+}
+
+interface MemoryCreateBackupRecordParams {
+  body: Record<string, JsonValue>;
+  baseUrl?: string;
+  authToken?: string;
+}
+
+interface OpenClawConfig {
+  plugins?: {
+    entries?: Record<string, {
+      config?: {
+        apiCoreBot?: {
+          baseUrl?: string;
+          authToken?: string;
+        };
+      };
+    }>;
+  };
+}
+
+const WORKSPACE_ROOT_FILES = [
+  'AGENTS.md',
+  'HEARTBEAT.md',
+  'IDENTITY.md',
+  'MEMORY.md',
+  'SoUL.md',
+  'TooLS.md',
+  'USER.md'
+];
+
+export const listMemoryFiles: MethodHandler = async (_params, context): Promise<JsonValue> => {
+  const workspaceDir = path.join(context.openclawRoot, 'workspace');
+  const items: JsonValue[] = [];
+
+  for (const fileName of WORKSPACE_ROOT_FILES) {
+    const filePath = path.join(workspaceDir, fileName);
+    if (!(await pathExists(filePath))) {
+      continue;
+    }
+
+    const stat = await fs.stat(filePath);
+    items.push({
+      path: `workspace/${fileName}`,
+      size: stat.size,
+      updatedAt: stat.mtime.toISOString()
+    });
+  }
+
+  const rootConfigPath = path.join(context.openclawRoot, 'openclaw.json');
+  if (await pathExists(rootConfigPath)) {
+    const stat = await fs.stat(rootConfigPath);
+    items.push({
+      path: 'openclaw.json',
+      size: stat.size,
+      updatedAt: stat.mtime.toISOString()
+    });
+  }
+
+  const credentialsDir = path.join(context.openclawRoot, 'credentials');
+  if (await pathExists(credentialsDir)) {
+    const credentialEntries = await fs.readdir(credentialsDir, { withFileTypes: true });
+    for (const entry of credentialEntries) {
+      if (!entry.isFile()) {
+        continue;
+      }
+
+      const fullPath = path.join(credentialsDir, entry.name);
+      const stat = await fs.stat(fullPath);
+      items.push({
+        path: `credentials/${entry.name}`,
+        size: stat.size,
+        updatedAt: stat.mtime.toISOString()
+      });
+    }
+  }
+
+  return {
+    count: items.length,
+    items
+  };
+};
+
+export const getMemoryFile: MethodHandler = async (params, context): Promise<JsonValue> => {
+  const objectParams = expectObject(params);
+  const filePath = expectString(objectParams.path, 'path');
+  const resolved = resolveMemoryPath(context.openclawRoot, filePath);
+  const content = await fs.readFile(resolved, 'utf8');
+  const stat = await fs.stat(resolved);
+
+  return {
+    path: filePath,
+    size: stat.size,
+    updatedAt: stat.mtime.toISOString(),
+    content
+  };
+};
+
+export const backupMemory: MethodHandler = async (_params, context): Promise<JsonValue> => {
+  const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+  const backupRoot = path.join(context.projectRoot, 'backups', 'memory', stamp);
+  const manifest: {
+    createdAt: string;
+    files: string[];
+  } = {
+    createdAt: new Date().toISOString(),
+    files: []
+  };
+
+  await ensureDir(backupRoot);
+
+  if (await copyIfExists(
+    path.join(context.openclawRoot, 'openclaw.json'),
+    path.join(backupRoot, 'openclaw.json')
+  )) {
+    manifest.files.push('openclaw.json');
+  }
+
+  for (const fileName of WORKSPACE_ROOT_FILES) {
+    const source = path.join(context.openclawRoot, 'workspace', fileName);
+    const dest = path.join(backupRoot, 'workspace', fileName);
+    if (await copyIfExists(source, dest)) {
+      manifest.files.push(path.relative(backupRoot, dest).replaceAll('\\', '/'));
+    }
+  }
+
+  const credentialsDir = path.join(context.openclawRoot, 'credentials');
+  if (await pathExists(credentialsDir)) {
+    const copiedCredentialFiles = await copyDirectoryTree(
+      credentialsDir,
+      path.join(backupRoot, 'credentials')
+    );
+    manifest.files.push(...copiedCredentialFiles.map((file) => `credentials/${file}`));
+  }
+
+  await fs.writeFile(
+    path.join(backupRoot, 'manifest.json'),
+    JSON.stringify(manifest, null, 2),
+    'utf8'
+  );
+
+  return {
+    backupId: stamp,
+    backupPath: backupRoot,
+    files: manifest.files
+  };
+};
+
+export const exportMemoryZip: MethodHandler = async (params, context): Promise<JsonValue> => {
+  const objectParams = ((params ? expectObject(params) : {}) as unknown) as MemoryExportZipParams;
+  const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+  const outputDirInput = objectParams.outputDir ?? path.join(context.projectRoot, 'exports', 'memory');
+  const outputDir = path.resolve(outputDirInput);
+  const zipFileName = sanitizeZipFileName(objectParams.zipFileName ?? `memory-backup-${stamp}.zip`);
+
+  await ensureDir(outputDir);
+
+  const snapshot = await backupMemory(undefined, context);
+  const snapshotRoot = expectString((snapshot as Record<string, JsonValue>).backupPath, 'backupPath');
+  const zipPath = path.join(outputDir, zipFileName);
+
+  await zipDirectory(snapshotRoot, zipPath);
+  const stat = await fs.stat(zipPath);
+
+  return {
+    ok: true,
+    zipPath,
+    size: stat.size,
+    snapshot
+  };
+};
+
+export const importMemoryZip: MethodHandler = async (params, context): Promise<JsonValue> => {
+  const objectParams = expectObject(params) as unknown as MemoryImportZipParams;
+  const zipPath = path.resolve(expectString(objectParams.zipPath, 'zipPath'));
+  const createBackup = objectParams.createBackup !== false;
+  const includePaths = Array.isArray(objectParams.includePaths)
+    ? objectParams.includePaths.filter((item): item is string => typeof item === 'string' && item.trim().length > 0)
+    : undefined;
+
+  if (!(await pathExists(zipPath))) {
+    throw new JsonRpcException(JSON_RPC_ERRORS.invalidParams, 'Zip file does not exist', { zipPath });
+  }
+
+  let backupResult: JsonValue | null = null;
+  if (createBackup) {
+    backupResult = await backupMemory(undefined, context);
+  }
+
+  const extractRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'openclaw-ts-memory-import-'));
+  try {
+    await unzipArchive(zipPath, extractRoot);
+    const importRoot = await resolveImportedRoot(extractRoot);
+    const restoredFiles = await restoreImportedMemory(importRoot, context.openclawRoot, includePaths);
+
+  return {
+    ok: true,
+    zipPath,
+    restoredFiles,
+    backup: backupResult
+    };
+  } finally {
+    await fs.rm(extractRoot, { recursive: true, force: true });
+  }
+};
+
+export const getMemoryPresignedPost: MethodHandler = async (params, context): Promise<JsonValue> => {
+  const objectParams = expectObject(params) as unknown as MemoryPresignedPostParams;
+  const body = isObject(objectParams.body as any) ? objectParams.body : null;
+  if (!body) {
+    throw new JsonRpcException(
+      JSON_RPC_ERRORS.invalidParams,
+      'Missing required parameter: body'
+    );
+  }
+
+  const endpointConfig = await resolveApiCoreBotEndpoint(context.openclawRoot, objectParams.baseUrl, objectParams.authToken);
+  const response = await postJson(
+    `${endpointConfig.baseUrl}/api-core-bot/front/s3/get-presigned-post`,
+    body,
+    endpointConfig.authToken
+  );
+
+  return {
+    ok: true,
+    endpoint: '/api-core-bot/front/s3/get-presigned-post',
+    data: response
+  };
+};
+
+export const createMemoryBackupRecord: MethodHandler = async (params, context): Promise<JsonValue> => {
+  const objectParams = expectObject(params) as unknown as MemoryCreateBackupRecordParams;
+  const body = isObject(objectParams.body as any) ? objectParams.body : null;
+  if (!body) {
+    throw new JsonRpcException(
+      JSON_RPC_ERRORS.invalidParams,
+      'Missing required parameter: body'
+    );
+  }
+
+  const endpointConfig = await resolveApiCoreBotEndpoint(context.openclawRoot, objectParams.baseUrl, objectParams.authToken);
+  const response = await postJson(
+    `${endpointConfig.baseUrl}/api-core-bot/front/file/backup/create`,
+    body,
+    endpointConfig.authToken
+  );
+
+  return {
+    ok: true,
+    endpoint: '/api-core-bot/front/file/backup/create',
+    data: response
+  };
+};
+
+function expectObject(value: JsonValue | undefined): Record<string, JsonValue> {
+  if (!value || Array.isArray(value) || typeof value !== 'object') {
+    throw new JsonRpcException(JSON_RPC_ERRORS.invalidParams, 'Params must be an object');
+  }
+
+  return value as Record<string, JsonValue>;
+}
+
+function expectString(value: JsonValue | undefined, fieldName: string): string {
+  if (typeof value !== 'string' || value.length === 0) {
+    throw new JsonRpcException(
+      JSON_RPC_ERRORS.invalidParams,
+      `Field '${fieldName}' must be a non-empty string`
+    );
+  }
+
+  return value;
+}
+
+function resolveMemoryPath(openclawRoot: string, relativePath: string): string {
+  const workspaceDir = path.join(openclawRoot, 'workspace');
+  const allowedRoots = [
+    workspaceDir,
+    path.join(openclawRoot, 'credentials'),
+    openclawRoot
+  ];
+
+  const candidate = path.join(openclawRoot, relativePath);
+
+  for (const allowedRoot of allowedRoots) {
+    try {
+      return ensureInside(allowedRoot, candidate);
+    } catch {
+      continue;
+    }
+  }
+
+  throw new JsonRpcException(
+    JSON_RPC_ERRORS.invalidParams,
+    'Only workspace memory files are readable',
+    { path: relativePath }
+  );
+}
+
+function sanitizeZipFileName(fileName: string): string {
+  return fileName.endsWith('.zip') ? fileName : `${fileName}.zip`;
+}
+
+async function resolveApiCoreBotEndpoint(
+  openclawRoot: string,
+  overrideBaseUrl?: string,
+  overrideAuthToken?: string
+): Promise<{ baseUrl: string; authToken?: string }> {
+  const config = await readJsonFile<OpenClawConfig>(path.join(openclawRoot, 'openclaw.json'));
+  const pluginConfig = config.plugins?.entries?.['rol-websocket-channel']?.config?.apiCoreBot ?? {};
+  const baseUrl = (overrideBaseUrl && overrideBaseUrl.trim()) || pluginConfig.baseUrl;
+
+  if (!baseUrl || !baseUrl.trim()) {
+    throw new JsonRpcException(
+      JSON_RPC_ERRORS.invalidParams,
+      'apiCoreBot.baseUrl is not configured'
+    );
+  }
+
+  const authToken = (overrideAuthToken && overrideAuthToken.trim()) || pluginConfig.authToken;
+  return {
+    baseUrl: baseUrl.replace(/\/+$/, ''),
+    authToken
+  };
+}
+
+async function postJson(
+  url: string,
+  body: Record<string, JsonValue>,
+  authToken?: string
+): Promise<unknown> {
+  const headers: Record<string, string> = {
+    'Content-Type': 'application/json'
+  };
+
+  if (authToken && authToken.trim()) {
+    headers.Authorization = `Bearer ${authToken.trim()}`;
+  }
+
+  const response = await fetch(url, {
+    method: 'POST',
+    headers,
+    body: JSON.stringify(body)
+  });
+
+  const payload = await response.json().catch(async () => await response.text());
+  if (!response.ok) {
+    throw new JsonRpcException(
+      JSON_RPC_ERRORS.internalError,
+      `Request failed: ${response.status}`,
+      {
+        url,
+        status: response.status,
+        payload
+      }
+    );
+  }
+
+  return payload;
+}
+
+async function zipDirectory(sourceDir: string, zipPath: string): Promise<void> {
+  await fs.rm(zipPath, { force: true });
+
+  if (process.platform === 'win32') {
+    await execFileAsync('powershell.exe', [
+      '-NoProfile',
+      '-Command',
+      `Compress-Archive -Path '${sourceDir}\\*' -DestinationPath '${zipPath}' -Force`
+    ]);
+    return;
+  }
+
+  await execFileAsync('zip', ['-r', zipPath, '.'], {
+    cwd: sourceDir
+  });
+}
+
+async function unzipArchive(zipPath: string, extractRoot: string): Promise<void> {
+  if (process.platform === 'win32') {
+    await execFileAsync('powershell.exe', [
+      '-NoProfile',
+      '-Command',
+      `Expand-Archive -Path '${zipPath}' -DestinationPath '${extractRoot}' -Force`
+    ]);
+    return;
+  }
+
+  await execFileAsync('unzip', ['-o', zipPath, '-d', extractRoot]);
+}
+
+async function resolveImportedRoot(extractRoot: string): Promise<string> {
+  const directWorkspace = path.join(extractRoot, 'workspace');
+  const directConfig = path.join(extractRoot, 'openclaw.json');
+  if ((await pathExists(directWorkspace)) || (await pathExists(directConfig))) {
+    return extractRoot;
+  }
+
+  const entries = await fs.readdir(extractRoot, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+
+    const candidate = path.join(extractRoot, entry.name);
+    if ((await pathExists(path.join(candidate, 'workspace'))) || (await pathExists(path.join(candidate, 'openclaw.json')))) {
+      return candidate;
+    }
+  }
+
+  throw new JsonRpcException(
+    JSON_RPC_ERRORS.invalidParams,
+    'Imported zip does not contain a valid memory snapshot'
+  );
+}
+
+async function restoreImportedMemory(
+  importRoot: string,
+  openclawRoot: string,
+  includePaths?: string[]
+): Promise<string[]> {
+  const restored: string[] = [];
+  const workspaceRoot = path.join(openclawRoot, 'workspace');
+  const importedCredentialsDir = path.join(importRoot, 'credentials');
+
+  if (shouldRestorePath('openclaw.json', includePaths) && await copyIfExists(
+    path.join(importRoot, 'openclaw.json'),
+    path.join(openclawRoot, 'openclaw.json')
+  )) {
+    restored.push('openclaw.json');
+  }
+
+  for (const fileName of WORKSPACE_ROOT_FILES) {
+    const source = path.join(importRoot, 'workspace', fileName);
+    const dest = path.join(workspaceRoot, fileName);
+    const logicalPath = `workspace/${fileName}`;
+    if (shouldRestorePath(logicalPath, includePaths) && await copyIfExists(source, dest)) {
+      restored.push(`workspace/${fileName}`);
+    }
+  }
+
+  if ((shouldRestorePath('credentials/', includePaths) || hasNestedInclude('credentials/', includePaths)) && await pathExists(importedCredentialsDir)) {
+    const restoredCredentialFiles = await copyDirectoryTree(
+      importedCredentialsDir,
+      path.join(openclawRoot, 'credentials'),
+      '',
+      includePaths
+    );
+    restored.push(...restoredCredentialFiles.map((file) => `credentials/${file}`));
+  }
+
+  return restored;
+}
+
+async function copyDirectoryTree(
+  sourceDir: string,
+  destDir: string,
+  relativePrefix = '',
+  includePaths?: string[]
+): Promise<string[]> {
+  await ensureDir(destDir);
+  const copied: string[] = [];
+  const entries = await fs.readdir(sourceDir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const source = path.join(sourceDir, entry.name);
+    const dest = path.join(destDir, entry.name);
+    const relativePath = relativePrefix ? `${relativePrefix}/${entry.name}` : entry.name;
+    const logicalPath = `credentials/${relativePath.replaceAll('\\', '/')}`;
+
+    if (entry.isDirectory()) {
+      if (!hasNestedInclude(`${logicalPath}/`, includePaths) && !shouldRestorePath(`${logicalPath}/`, includePaths)) {
+        continue;
+      }
+      const nested = await copyDirectoryTree(source, dest, relativePath, includePaths);
+      copied.push(...nested);
+      continue;
+    }
+
+    if (!entry.isFile()) {
+      continue;
+    }
+
+    if (!shouldRestorePath(logicalPath, includePaths) && !shouldRestorePath('credentials/', includePaths)) {
+      continue;
+    }
+
+    await copyIfExists(source, dest);
+    copied.push(relativePath.replaceAll('\\', '/'));
+  }
+
+  return copied;
+}
+
+function shouldRestorePath(targetPath: string, includePaths?: string[]): boolean {
+  if (!includePaths || includePaths.length === 0) {
+    return true;
+  }
+
+  const normalizedTarget = normalizeLogicalPath(targetPath);
+  return includePaths.some((value) => normalizeLogicalPath(value) === normalizedTarget);
+}
+
+function hasNestedInclude(prefix: string, includePaths?: string[]): boolean {
+  if (!includePaths || includePaths.length === 0) {
+    return true;
+  }
+
+  const normalizedPrefix = normalizeLogicalPath(prefix).replace(/\/?$/, '/');
+  return includePaths.some((value) => normalizeLogicalPath(value).startsWith(normalizedPrefix));
+}
+
+function normalizeLogicalPath(value: string): string {
+  return value.replaceAll('\\', '/').replace(/^\/+/, '').replace(/\/+$/, '');
+}