@byted-las/contextlake-openclaw 1.0.0 → 1.0.3

package/dist/src/utils/config.d.ts

@@ -1 +1,34 @@
-export declare function getPluginConfig(ctx: any): any;
+export interface EmbeddingConfig {
+    provider: string;
+    model_name: string;
+    api_key?: string;
+    api_base?: string;
+    dimensions?: number;
+    encoding_format?: string;
+}
+export interface MetadataStorageConfig {
+    type: 'local' | 'remote';
+    lancedb_uri?: string;
+    embedding?: EmbeddingConfig;
+}
+export interface FileStorageConfig {
+    type: 'local' | 'tos';
+    local_base_dir?: string;
+    tos?: {
+        access_key?: string;
+        secret_key?: string;
+        region?: string;
+        path?: string;
+        endpoint?: string;
+        sts_token?: string;
+    };
+}
+export interface StoragePolicyConfig {
+    max_inline_size_kb?: number;
+}
+export interface ContextLakeConfig {
+    metadata_storage?: MetadataStorageConfig;
+    file_storage?: FileStorageConfig;
+    storage_policy?: StoragePolicyConfig;
+}
+export declare function getPluginConfig(ctx: any): ContextLakeConfig;

package/dist/src/utils/config.js

@@ -1,16 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getPluginConfig = getPluginConfig;
+const credentials_1 = require("./credentials");
 function getPluginConfig(ctx) {
+    const creds = (0, credentials_1.loadCredentials)();
     return ctx.config?.plugins?.entries?.['contextlake-openclaw']?.config || {
         metadata_storage: {
             type: 'local',
             lancedb_uri: require('path').join(require('os').homedir(), '.openclaw', 'contextlake', 'data'),
             embedding: {
-                provider: 'local',
-                model_name: 'hf:CompendiumLabs/bge-small-zh-v1.5-gguf/bge-small-zh-v1.5-f16.gguf'
+                provider: 'las',
+                model_name: 'doubao-embedding-vision-250615',
+                api_key: process.env.LAS_API_KEY || creds.LAS_API_KEY,
+                api_base: process.env.LAS_BASE_URL || 'https://operator.las.cn-beijing.volces.com',
+                dimensions: 2048,
+                encoding_format: 'float'
             }
         },
-        file_storage: { type: 'local', local_base_dir: require('path').join(require('os').homedir(), '.openclaw', 'contextlake', 'files') }
+        file_storage: {
+            type: 'local',
+            local_base_dir: require('path').join(require('os').homedir(), '.openclaw', 'contextlake', 'files'),
+            tos: {
+                access_key: process.env.VOLCENGINE_ACCESS_KEY || creds.VOLCENGINE_ACCESS_KEY,
+                secret_key: process.env.VOLCENGINE_SECRET_KEY || creds.VOLCENGINE_SECRET_KEY
+            }
+        }
     };
 }

package/dist/src/utils/credentials.d.ts

@@ -0,0 +1,8 @@
+export interface Credentials {
+    LAS_API_KEY?: string;
+    VOLCENGINE_ACCESS_KEY?: string;
+    VOLCENGINE_SECRET_KEY?: string;
+}
+export declare function loadCredentials(): Credentials;
+export declare function saveCredentials(creds: Credentials): void;
+export declare function promptForInput(promptText: string, defaultVal?: string): Promise<string>;

package/dist/src/utils/credentials.js

@@ -0,0 +1,77 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadCredentials = loadCredentials;
+exports.saveCredentials = saveCredentials;
+exports.promptForInput = promptForInput;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const readline = __importStar(require("readline"));
+const CONFIG_DIR = path.join(os.homedir(), '.openclaw', 'contextlake');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'credentials.json');
+function loadCredentials() {
+    if (fs.existsSync(CONFIG_FILE)) {
+        try {
+            const content = fs.readFileSync(CONFIG_FILE, 'utf-8');
+            return JSON.parse(content);
+        }
+        catch (e) {
+            // ignore
+        }
+    }
+    return {};
+}
+function saveCredentials(creds) {
+    if (!fs.existsSync(CONFIG_DIR)) {
+        fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+    const current = loadCredentials();
+    const updated = { ...current, ...creds };
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(updated, null, 2), { mode: 0o600 });
+}
+async function promptForInput(promptText, defaultVal) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    const displayPrompt = defaultVal ? `${promptText} [${defaultVal}]: ` : `${promptText}: `;
+    return new Promise((resolve) => {
+        rl.question(displayPrompt, (answer) => {
+            rl.close();
+            resolve(answer.trim() || defaultVal || '');
+        });
+    });
+}

package/index.ts

@@ -1,11 +1,11 @@
 // @ts-ignore
-import { PluginContext } from 'openclaw/plugin-sdk';
+import type { OpenClawPluginApi, PluginLogger } from 'openclaw/plugin-sdk';
 import { registerAll } from './src/commands';
 
 const plugin = {
   id: 'contextlake-openclaw',
   name: 'ContextLake',
-  version: '1.1.0',
+  version: '1.0.2',
   description: 'A lightweight knowledge base plugin for OpenClaw using LanceDB and TOS, with data profiling support',
   configSchema: {
     type: 'object',
@@ -57,12 +57,12 @@ const plugin = {
       }
     }
   },
-  register(ctx: any) {
-    const logger = ctx.logger || {
-        info: (msg: string, ...args: any[]) => console.log(msg, ...args),
-        warn: (msg: string, ...args: any[]) => console.warn(msg, ...args),
-        error: (msg: string, ...args: any[]) => console.error(msg, ...args),
-        debug: (msg: string, ...args: any[]) => console.debug(msg, ...args),
+  register(ctx: OpenClawPluginApi) {
+    const logger: PluginLogger = ctx.logger || {
+        info: (msg: string) => console.log(msg),
+        warn: (msg: string) => console.warn(msg),
+        error: (msg: string) => console.error(msg),
+        debug: (msg: string) => console.debug(msg),
     };
 
     // Add logging

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "contextlake-openclaw",
   "name": "ContextLake",
-  "version": "1.1.0",
+  "version": "1.0.3",
   "description": "A lightweight knowledge base plugin for OpenClaw using LanceDB and TOS, with data profiling support",
   "skills": ["./src/skills"],
   "configSchema": {

package/package.json

@@ -1,31 +1,32 @@
 {
   "name": "@byted-las/contextlake-openclaw",
-  "version": "1.0.0",
+  "version": "1.0.3",
   "description": "ContextLake OpenClaw Plugin for managing knowledge base",
   "main": "index.ts",
   "files": [
     "dist",
-    "bin",
     "index.ts",
     "src",
     "openclaw.plugin.json"
   ],
-  "bin": {
-    "contextlake-openclaw": "./bin/contextlake-openclaw.js"
-  },
   "openclaw": {
     "extensions": [
       "./dist/index.js"
     ]
   },
   "scripts": {
-    "build": "tsc",
+    "build": "tsc && npm run copy-assets",
+    "copy-assets": "cp -r src/skills/*/*.md dist/src/skills/ 2>/dev/null || true && for dir in src/skills/*; do if [ -d \"$dir\" ]; then target=\"dist/$dir\"; mkdir -p \"$target\"; cp \"$dir\"/*.md \"$target\"/ 2>/dev/null || true; fi; done && mkdir -p dist/src/lib/scripts && cp src/lib/scripts/*.py dist/src/lib/scripts/ 2>/dev/null || true",
     "test": "vitest --reporter verbose",
     "test:local": "npx ts-node scripts/local-test.ts",
     "test:profiler": "npx ts-node scripts/local-profiler-test.ts",
     "cli": "npx ts-node scripts/cli.ts"
   },
-  "keywords": ["openclaw", "contextlake", "plugin"],
+  "keywords": [
+    "openclaw",
+    "contextlake",
+    "plugin"
+  ],
   "author": "byted-las",
   "license": "ISC",
   "engines": {

package/src/client/lancedb.ts

@@ -38,27 +38,27 @@ export class ContextLakeLanceDBClient {
   async getTable(tableName: string = 'documents', dim: number = 0) {
     if (this.table) return this.table;
     await this.connect();
-    
+
     const tableNames = await this.db!.tableNames();
     if (tableNames.includes(tableName)) {
       this.table = await this.db!.openTable(tableName);
     } else {
       if (dim <= 0) {
         // Fallback: use embedding provider to infer dimension only if needed
-        const dummyVec = await this.embeddingProvider.generateEmbedding("init");
+        const dummyVec = await this.embeddingProvider.generateEmbedding('init');
         dim = dummyVec.length;
       }
-      
+
       // @ts-ignore
       this.table = await this.db!.createTable(tableName, [
-        { 
-          id: 'schema_init', 
-          vector: Array(dim).fill(0), 
-          text: '', 
-          source: '', 
+        {
+          id: 'schema_init',
+          vector: Array(dim).fill(0),
+          text: '',
+          source: '',
           file_type: '',
           storage_type: '',
-          url: '', 
+          url: '',
           metadata: '{}',
           created_at: 0,
           binary_data: Buffer.from('')
@@ -76,27 +76,38 @@ export class ContextLakeLanceDBClient {
   }
 
   async search(query: string, limit: number = 5, filter?: string) {
-    const vector = await this.embeddingProvider.generateEmbedding(query);
+    const normalizedLimit = Number.isFinite(limit) ? Math.max(1, Math.floor(limit)) : 5;
     const table = await this.getTable();
+
+    if (!query || !query.trim()) {
+      let fallbackQuery = table.query().limit(normalizedLimit);
+      if (filter) {
+        fallbackQuery = fallbackQuery.where(filter);
+      }
+      return await fallbackQuery.toArray();
+    }
+
+    const vector = await this.embeddingProvider.generateMultimodalEmbedding!([{ type: 'text', text: query }]);
     // @ts-ignore
-    let search = table.vectorSearch(vector).limit(limit);
+    let search = table.vectorSearch(vector).limit(normalizedLimit);
     if (filter) {
       search = search.where(filter);
     }
     return await search.toArray();
   }
-  
+
   async delete(filter: string) {
-      const table = await this.getTable();
-      await table.delete(filter);
+    const table = await this.getTable();
+    await table.delete(filter);
   }
-  
+
   async list(limit: number = 100, filter?: string) {
-      const table = await this.getTable();
-      let query = table.query().limit(limit);
-      if (filter) {
-        query = query.where(filter);
-      }
-      return await query.toArray();
+    const normalizedLimit = Number.isFinite(limit) ? Math.max(1, Math.floor(limit)) : 100;
+    const table = await this.getTable();
+    let query = table.query().limit(normalizedLimit);
+    if (filter) {
+      query = query.where(filter);
+    }
+    return await query.toArray();
   }
 }

package/src/commands/cli.ts

@@ -1,20 +1,83 @@
 // @ts-ignore
-import { PluginContext } from 'openclaw/plugin-sdk';
-import { ingestAssets } from '../lib/actions/ingest';
+import { ingestSource } from '../lib/actions/ingest';
 import { retrieveAssets } from '../lib/actions/retrieve';
 import { listAssets, deleteAssets } from '../lib/actions/manage';
+import { connectDataSource, ConnectParams } from '../lib/actions/profiler';
+import { loadCredentials, saveCredentials, promptForInput } from '../utils/credentials';
+import { ContextLakeConfig } from '../utils/config';
 
-export function getCliCommands(pluginConfig: any, logger: any) {
+function parseOptionalInt(value: any, fallback: number): number {
+    const parsed = Number.parseInt(String(value), 10);
+    return Number.isFinite(parsed) ? parsed : fallback;
+}
+
+function parseMetadata(metadata: any): Record<string, any> {
+    if (!metadata) {
+        return {};
+    }
+
+    if (typeof metadata === 'object') {
+        return metadata;
+    }
+
+    if (typeof metadata !== 'string') {
+        throw new Error('metadata must be a JSON object or JSON string');
+    }
+
+    try {
+        const parsed = JSON.parse(metadata);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            throw new Error('metadata must be a JSON object');
+        }
+        return parsed;
+    } catch (error: any) {
+        throw new Error(`Invalid metadata JSON: ${error.message}`);
+    }
+}
+
+export function getCliCommands(pluginConfig: ContextLakeConfig, logger: any) {
     return {
-        ingestAction: async (files: any, options: any) => {
-            logger.info(`[${new Date().toISOString()}] [ContextLake] CLI ingest started`, { files, options });
+        connectAction: async (datasource_name: string, options: any) => {
+            logger.info(`[${new Date().toISOString()}] [ContextLake] CLI connect started`, { datasource_name, options });
             try {
-                const metadata = options.metadata ? JSON.parse(options.metadata) : {};
-                const result = await ingestAssets({
-                    files,
-                    metadata,
-                    chunkSize: parseInt(options.chunkSize),
-                    overlap: parseInt(options.overlap)
+                const params: ConnectParams = {
+                    datasource_name,
+                    vendor: options.vendor,
+                    endpoint: options.endpoint,
+                    access_key: options.ak,
+                    secret_key: options.sk,
+                    region: options.region,
+                    bucket: options.bucket,
+                    prefix: options.prefix,
+                    sample_rows: parseInt(options.sampleRows),
+                };
+
+                // eslint-disable-next-line no-console
+                console.log(`[contextlake connect] Connecting to datasource "${datasource_name}"...`);
+                // eslint-disable-next-line no-console
+                console.log(`  vendor: ${params.vendor}`);
+                // eslint-disable-next-line no-console
+                console.log(`  bucket: ${params.bucket}`);
+                // eslint-disable-next-line no-console
+                console.log(`  prefix: ${params.prefix}`);
+
+                const result = await connectDataSource(params);
+                // eslint-disable-next-line no-console
+                console.log(JSON.stringify(result, null, 2));
+                logger.info(`[${new Date().toISOString()}] [ContextLake] CLI connect success`);
+            } catch (e: any) {
+                // eslint-disable-next-line no-console
+                console.error('Error:', e.message);
+                logger.error(`[${new Date().toISOString()}] [ContextLake] CLI connect failed`, { error: e.message, stack: e.stack });
+                process.exitCode = 1;
+            }
+        },
+
+        ingestAction: async (datasource_name: string) => {
+            logger.info(`[${new Date().toISOString()}] [ContextLake] CLI ingest started`, { datasource_name });
+            try {
+                const result = await ingestSource({
+                    datasource_name
                 }, pluginConfig, logger);
                 // eslint-disable-next-line no-console
                 console.log(JSON.stringify(result, null, 2));
@@ -30,7 +93,7 @@ export function getCliCommands(pluginConfig: any, logger: any) {
             try {
                 const result = await retrieveAssets({
                     query,
-                    top_k: parseInt(options.topK),
+                    top_k: parseOptionalInt(options.topK, 5),
                     filter: options.filter,
                     include_binary: options.binary
                 }, pluginConfig, logger);
@@ -47,7 +110,7 @@ export function getCliCommands(pluginConfig: any, logger: any) {
             logger.info(`[${new Date().toISOString()}] [ContextLake] CLI list started`, { options });
             try {
                 const result = await listAssets({
-                    limit: parseInt(options.limit)
+                    limit: parseOptionalInt(options.limit, 100)
                 }, pluginConfig, logger);
                 // eslint-disable-next-line no-console
                 console.log(JSON.stringify(result, null, 2));
@@ -72,6 +135,35 @@ export function getCliCommands(pluginConfig: any, logger: any) {
                 console.error('Error:', e.message);
                 logger.error(`[${new Date().toISOString()}] [ContextLake] CLI delete failed`, { error: e.message, stack: e.stack });
             }
+        },
+
+        onboardAction: async () => {
+            logger.info(`[${new Date().toISOString()}] [ContextLake] CLI onboard started`);
+            try {
+                const currentCreds = loadCredentials();
+                // eslint-disable-next-line no-console
+                console.log('Welcome to ContextLake Onboarding!');
+                // eslint-disable-next-line no-console
+                console.log('Please provide your credentials below. Press enter to keep the current value.');
+                
+                const lasApiKey = await promptForInput('LAS_API_KEY', currentCreds.LAS_API_KEY);
+                const volcengineAccessKey = await promptForInput('VOLCENGINE_ACCESS_KEY', currentCreds.VOLCENGINE_ACCESS_KEY);
+                const volcengineSecretKey = await promptForInput('VOLCENGINE_SECRET_KEY', currentCreds.VOLCENGINE_SECRET_KEY);
+                
+                const newCreds = {
+                    LAS_API_KEY: lasApiKey,
+                    VOLCENGINE_ACCESS_KEY: volcengineAccessKey,
+                    VOLCENGINE_SECRET_KEY: volcengineSecretKey
+                };
+                
+                saveCredentials(newCreds);
+                // eslint-disable-next-line no-console
+                console.log('Credentials saved successfully!');
+                logger.info(`[${new Date().toISOString()}] [ContextLake] CLI onboard success`);
+            } catch (e: any) {
+                console.error('Error during onboarding:', e.message);
+                logger.error(`[${new Date().toISOString()}] [ContextLake] CLI onboard failed`, { error: e.message, stack: e.stack });
+            }
         }
     };
 }

package/src/commands/index.ts

@@ -2,29 +2,41 @@ import { getAgentTools } from './tools';
 import { getCliCommands } from './cli';
 import { getSlashCommands } from './slashcmd';
 import { getPluginConfig } from '../utils/config';
-import { connectDataSource, ConnectParams } from '../skills/las-data-profiler';
+// @ts-ignore
+import type { OpenClawPluginApi, PluginLogger, AnyAgentTool } from 'openclaw/plugin-sdk';
 
-export function registerAll(ctx: any, logger: any) {
+export function registerAll(ctx: OpenClawPluginApi, logger: PluginLogger) {
     const pluginConfig = getPluginConfig(ctx);
 
     // Register Agent Tools
     try {
         const tools = getAgentTools(pluginConfig, logger);
         
-        ctx.registerTool(tools.ingestTool);
+        ctx.registerTool(tools.ingestTool );
         logger.info(`[${new Date().toISOString()}] [ContextLake] Tool registered: ${tools.ingestTool.name}`);
         
-        ctx.registerTool(tools.retrieveTool);
+        ctx.registerTool(tools.retrieveTool );
         logger.info(`[${new Date().toISOString()}] [ContextLake] Tool registered: ${tools.retrieveTool.name}`);
         
-        ctx.registerTool(tools.listTool);
+        ctx.registerTool(tools.listTool );
         logger.info(`[${new Date().toISOString()}] [ContextLake] Tool registered: ${tools.listTool.name}`);
         
-        ctx.registerTool(tools.deleteTool);
+        ctx.registerTool(tools.deleteTool );
         logger.info(`[${new Date().toISOString()}] [ContextLake] Tool registered: ${tools.deleteTool.name}`);
         
+        ctx.registerTool(tools.lasDataProfilerTool );
+        logger.info(`[${new Date().toISOString()}] [ContextLake] Tool registered: ${tools.lasDataProfilerTool.name}`);
+        
+        ctx.registerTool(tools.listDatasourceTool );
+        logger.info(`[${new Date().toISOString()}] [ContextLake] Tool registered: ${tools.listDatasourceTool.name}`);
+
+        for (const lasTool of tools.lasTools) {
+            ctx.registerTool(lasTool);
+            logger.info(`[${new Date().toISOString()}] [ContextLake] Tool registered: ${lasTool.name}`);
+        }
+        
     } catch (error: any) {
-        logger.error(`[${new Date().toISOString()}] [ContextLake] Error registering agent tools: ${error.message}`, { stack: error.stack });
+        logger.error(`[${new Date().toISOString()}] [ContextLake] Error registering agent tools: ${error.message}${error.stack ? '\\n' + error.stack : ''}`);
         throw error;
     }
 
@@ -49,39 +61,11 @@ export function registerAll(ctx: any, logger: any) {
                 .requiredOption('--bucket <bucket>', 'Bucket name (or local root directory for local vendor)')
                 .requiredOption('--prefix <prefix>', 'Path prefix to limit scan scope')
                 .option('--sample-rows <number>', 'Number of rows to sample per structured file', '100')
-                .action(async (datasource_name: string, options: any) => {
-                    try {
-                        const params: ConnectParams = {
-                            datasource_name,
-                            vendor: options.vendor,
-                            endpoint: options.endpoint,
-                            access_key: options.ak,
-                            secret_key: options.sk,
-                            region: options.region,
-                            bucket: options.bucket,
-                            prefix: options.prefix,
-                            sample_rows: parseInt(options.sampleRows),
-                        };
-
-                        console.log(`[contextlake connect] Connecting to datasource "${datasource_name}"...`);
-                        console.log(`  vendor: ${params.vendor}`);
-                        console.log(`  bucket: ${params.bucket}`);
-                        console.log(`  prefix: ${params.prefix}`);
-
-                        const result = await connectDataSource(params);
-                        console.log(JSON.stringify(result, null, 2));
-                    } catch (e: any) {
-                        console.error('Error:', e.message);
-                        process.exitCode = 1;
-                    }
-                });
+                .action(commands.connectAction);
 
             // Ingest
-            contextlake.command('ingest <files...>')
-                .description('Ingest one or more files into the knowledge base')
-                .option('-c, --chunk-size <number>', 'Chunk size for text splitting', '500')
-                .option('-o, --overlap <number>', 'Chunk overlap size', '50')
-                .option('-m, --metadata <json>', 'JSON metadata to attach to the documents')
+            contextlake.command('ingest <datasource_name>')
+                .description('Process and ingest all files from a connected data source into the knowledge base')
                 .action(commands.ingestAction);
 
             // Search
@@ -104,11 +88,16 @@ export function registerAll(ctx: any, logger: any) {
                 .option('--ids <ids...>', 'List of specific file IDs to delete')
                 .option('-f, --filter <string>', 'Filter string to match documents for deletion')
                 .action(commands.deleteAction);
+
+            // Onboard
+            contextlake.command('onboard')
+                .description('Configure credentials for ContextLake')
+                .action(commands.onboardAction);
                 
         }, { commands: ['contextlake'] });
         logger.info(`[${new Date().toISOString()}] [ContextLake] CLI commands registered`);
     } catch (error: any) {
-        logger.error(`[${new Date().toISOString()}] [ContextLake] Error registering CLI commands: ${error.message}`, { stack: error.stack });
+        logger.error(`[${new Date().toISOString()}] [ContextLake] Error registering CLI commands: ${error.message}${error.stack ? '\\n' + error.stack : ''}`);
         throw error;
     }
     
@@ -123,7 +112,7 @@ export function registerAll(ctx: any, logger: any) {
         
         ctx.registerCommand({
             name: 'contextlake-ingest',
-            description: 'Ingest files into the knowledge base (usage: /contextlake-ingest file1 file2)',
+            description: 'Process and ingest all files from a connected data source (usage: /contextlake-ingest <datasource_name>)',
             acceptsArgs: true,
             handler: slashCommands.ingestHandler
         });
@@ -148,9 +137,23 @@ export function registerAll(ctx: any, logger: any) {
             acceptsArgs: true,
             handler: slashCommands.deleteHandler
         });
+
+        ctx.registerCommand({
+            name: 'contextlake-profiler',
+            description: 'Connect to a data source and profile its structure (usage: /contextlake-profiler <datasource_name> <vendor> <bucket> <prefix>)',
+            acceptsArgs: true,
+            handler: slashCommands.profilerHandler
+        });
+
+        ctx.registerCommand({
+            name: 'contextlake-list-datasource',
+            description: 'List all connected and profiled data sources (usage: /contextlake-list-datasource)',
+            acceptsArgs: false,
+            handler: slashCommands.listDatasourceHandler
+        });
         
         logger.info(`[${new Date().toISOString()}] [ContextLake] Slash commands registered`);
     } catch (error: any) {
-        logger.error(`[${new Date().toISOString()}] [ContextLake] Error registering Slash commands: ${error.message}`, { stack: error.stack });
+        logger.error(`[${new Date().toISOString()}] [ContextLake] Error registering Slash commands: ${error.message}${error.stack ? '\\n' + error.stack : ''}`);
     }
-}
+}