feat: Add pagination support and account status management across database adapters (CONFLICTED)

.env.example

@@ -968,3 +968,9 @@ BUNDLE_EXECUTOR_ADDRESS=          # Address of the bundle executor contract
 DESK_EXCHANGE_PRIVATE_KEY=                  # Required for trading and cancelling orders
 DESK_EXCHANGE_NETWORK=                      # "mainnet" or "testnet
 
+# JWT
+JWT_ENABLED=
+JWT_SECRET_KEY=
+JWT_EXPIRED=
+JWT_USERNAME=
+JWT_PASSWORD=

agent/.gitignore

@@ -1,6 +1,3 @@
-*.ts
-!index.ts
-!character.ts
 .env
 *.env
 .env*

agent/package.json

@@ -96,7 +96,6 @@
         "@elizaos/plugin-twitter": "workspace:*",
         "@elizaos/plugin-primus": "workspace:*",
         "@elizaos/plugin-cronoszkevm": "workspace:*",
-        "@elizaos/plugin-cronos": "workspace:*",
         "@elizaos/plugin-3d-generation": "workspace:*",
         "@elizaos/plugin-fuel": "workspace:*",
         "@elizaos/plugin-avalanche": "workspace:*",

agent/src/client.ts

@@ -0,0 +1,87 @@
+import path from "path";
+import fs from "fs";
+import { fileURLToPath } from 'url';
+import { elizaLogger } from "@elizaos/core";
+import { getAndParseReadme } from "./document";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+interface ClientInfo {
+  package: string;
+  name: string,
+  env?: Record<string, string|number|boolean>;
+  document?: string;
+}
+
+async function getClientInfo(clientDir: string): Promise<ClientInfo | null> {
+  try {
+    // get package.json
+    const packageJsonPath = path.join(clientDir, 'package.json');
+    elizaLogger.debug(`Reading package.json from: ${packageJsonPath}`);
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+
+    // try to read README.md with case-insensitive search
+    const {document, env} = await getAndParseReadme(clientDir);
+
+    return {
+      package: packageJson.name,
+      name: packageJson.name.startsWith('@elizaos/client-') ? packageJson.name.slice(16) : packageJson.name,
+      env,
+      document,
+    };
+  } catch (error) {
+    elizaLogger.error(`Error loading client from ${clientDir}:`, error.message);
+    return null;
+  }
+}
+
+export async function getClients() {
+  try {
+    // Read package.json from the agent directory
+    const packageJsonPath = path.resolve(__dirname, '../package.json');
+    elizaLogger.log(`Reading package.json from: ${packageJsonPath}`);
+
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+
+    // Get all client dependencies (starting with @elizaos/client-)
+    const clientPackages = Object.keys(packageJson.dependencies || {})
+      .filter(dep => dep.startsWith('@elizaos/client-'))
+      .sort();
+
+    elizaLogger.info(`Found ${clientPackages.length} client packages in package.json`);
+
+    // Get client info for each package
+    const clientsInfo = await Promise.all(
+      clientPackages.map(async (packageName) => {
+        try {
+          // Import client module to get client info
+          elizaLogger.log(`load client: ${packageName}`);
+          // Try to read README.md from node_modules
+          const nodeModulesDir = path.resolve(__dirname, '../node_modules');
+          const clientDir = path.join(nodeModulesDir, packageName);
+
+          const {document, env} = await getAndParseReadme(clientDir);
+
+          return {
+            package: packageName,
+            name: packageName.startsWith('@elizaos/client-') ? packageName.slice(16) : packageName,
+            env, 
+            document,
+          };
+        } catch (error) {
+          elizaLogger.error(`Error loading client ${packageName}:`, error.message);
+          return null;
+        }
+      })
+    );
+
+    // Filter out clients that failed to load
+    const validClients = clientsInfo.filter(Boolean);
+    elizaLogger.info(`Successfully loaded ${validClients.length} clients`);
+
+    return validClients;
+  } catch (error) {
+    elizaLogger.error('Error getting clients:', error);
+    throw error;
+  }
+}

agent/src/document.ts

@@ -0,0 +1,51 @@
+import path from "path";
+import fs from "fs";
+import { elizaLogger } from "@elizaos/core";
+
+export async function getReadme(dir: string) {
+    // try to read README.md with case-insensitive search
+    try {
+        const files = fs.readdirSync(dir);
+        const readmeFile = files.find(file => file.toLowerCase() === 'readme.md');
+        if (readmeFile) {
+            return fs.readFileSync(path.join(dir, readmeFile), 'utf-8');
+        }
+    } catch (error) {
+        elizaLogger.debug(`No README.md found in ${dir}`);
+        return null;
+    }
+}
+
+export async function getAndParseReadme(dir: string) {
+    const document = await getReadme(dir);
+    const env: Record<string, string|number|boolean> = {};
+    if (!document) {
+        return {document: null, env: {}};
+    }
+    const envMatch = document.match(/```env\n([\s\S]*?)\n```/);
+    if (envMatch) {
+        const envLines = envMatch[1].split('\n').map(line => line.trim())
+            .filter(line => line.length > 0 && !line.startsWith('#') && !line.startsWith(' #'));
+        for (const line of envLines) {
+            // remove comment
+            const lineWithoutComment = line.split('#')[0].trim();
+            const [key, ...valueParts] = lineWithoutComment.split('=');
+            let value:any = valueParts.join('=').trim(); // handle value with =
+
+            // handle number
+            if (/^\d+$/.test(value)) {
+                value = Number.parseInt(value, 10);
+            }
+            // else if (value.toLowerCase() === "true") {
+            //     value = true;
+            // } else if (value.toLowerCase() === "false") {
+            //     value = false;
+            // } 
+
+            if (key) {
+                env[key.trim()] = value;
+            }
+        }
+    }
+    return {document, env};
+}