@bike4mind/cli 0.2.8-cli-bash-tools.17140 → 0.2.8-cli-bash-tools.17146

package/dist/index.js

@@ -9183,6 +9183,17 @@ var MementoEvalResponseSchema = z142.object({
 // ../../b4m-core/packages/services/dist/src/auth/AccessTokenGeneratorService.js
 import jwt2 from "jsonwebtoken";
 
+// ../../b4m-core/packages/services/dist/src/cliTools/types.js
+var ToolErrorType;
+(function(ToolErrorType2) {
+  ToolErrorType2["INVALID_INPUT"] = "INVALID_INPUT";
+  ToolErrorType2["API_KEY_MISSING"] = "API_KEY_MISSING";
+  ToolErrorType2["EXTERNAL_API_ERROR"] = "EXTERNAL_API_ERROR";
+  ToolErrorType2["RATE_LIMIT"] = "RATE_LIMIT";
+  ToolErrorType2["NETWORK_ERROR"] = "NETWORK_ERROR";
+  ToolErrorType2["UNKNOWN"] = "UNKNOWN";
+})(ToolErrorType || (ToolErrorType = {}));
+
 // src/utils/diffPreview.ts
 import * as Diff from "diff";
 import { readFile } from "fs/promises";
@@ -9233,6 +9244,338 @@ Last modified: ${stats.mtime.toLocaleString()}`;
   }
 }
 
+// src/utils/Logger.ts
+import fs10 from "fs/promises";
+import path12 from "path";
+import os from "os";
+var Logger2 = class _Logger {
+  constructor() {
+    this.logFilePath = null;
+    this.sessionId = null;
+    this.fileLoggingEnabled = true;
+    this.consoleVerbose = false;
+  }
+  static {
+    this.instance = null;
+  }
+  static getInstance() {
+    if (!_Logger.instance) {
+      _Logger.instance = new _Logger();
+    }
+    return _Logger.instance;
+  }
+  /**
+   * Initialize the logger with a session ID
+   */
+  async initialize(sessionId) {
+    this.sessionId = sessionId;
+    const debugDir = path12.join(os.homedir(), ".bike4mind", "debug");
+    await fs10.mkdir(debugDir, { recursive: true });
+    this.logFilePath = path12.join(debugDir, `${sessionId}.txt`);
+    await this.writeToFile("INFO", "=== CLI SESSION START ===");
+  }
+  /**
+   * Set whether verbose console logging is enabled
+   */
+  setVerbose(enabled) {
+    this.consoleVerbose = enabled;
+  }
+  /**
+   * Set whether file logging is enabled
+   */
+  setFileLoggingEnabled(enabled) {
+    this.fileLoggingEnabled = enabled;
+  }
+  /**
+   * DEBUG level - verbose-only console, always file
+   */
+  debug(message) {
+    this.writeToFile("DEBUG", message).catch(() => {
+    });
+    if (this.consoleVerbose) {
+      console.log(message);
+    }
+  }
+  /**
+   * INFO level - always shown to user
+   */
+  info(message) {
+    this.writeToFile("INFO", message).catch(() => {
+    });
+    console.log(message);
+  }
+  /**
+   * WARN level - always shown to user
+   */
+  warn(message) {
+    this.writeToFile("WARN", message).catch(() => {
+    });
+    console.warn(message);
+  }
+  /**
+   * ERROR level - always shown to user
+   */
+  error(message, err) {
+    this.writeToFile("ERROR", message).catch(() => {
+    });
+    if (err) {
+      this.logErrorDetailsToFile(err).catch(() => {
+      });
+    }
+    console.error(message);
+  }
+  /**
+   * Write log entry to file
+   */
+  async writeToFile(level, message) {
+    if (!this.fileLoggingEnabled || !this.logFilePath) {
+      return;
+    }
+    try {
+      const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").substring(0, 19);
+      const logEntry = `[${timestamp}] [${level}] ${message}
+`;
+      await fs10.appendFile(this.logFilePath, logEntry, "utf-8");
+    } catch (error) {
+      console.error("File logging failed:", error);
+    }
+  }
+  /**
+   * Log error details to file
+   */
+  async logErrorDetailsToFile(err) {
+    if (!this.fileLoggingEnabled || !this.logFilePath) {
+      return;
+    }
+    try {
+      if (err && typeof err === "object" && "response" in err && err.response) {
+        const response = err.response;
+        const config = err && typeof err === "object" && "config" in err ? err.config : void 0;
+        await this.writeToFile("ERROR", `  Status: ${response.status} ${response.statusText || ""}`);
+        await this.writeToFile("ERROR", `  URL: ${config?.url || "unknown"}`);
+        await this.writeToFile("ERROR", `  Headers: ${this.safeStringify(response.headers)}`);
+        if (response.data) {
+          const errorText = this.extractErrorMessage(response.data);
+          if (errorText.trim().startsWith("<!DOCTYPE") || errorText.trim().startsWith("<html")) {
+            await this.writeToFile("ERROR", `  Response Type: HTML Error Page`);
+            const parsedError = this.parseHtmlError(errorText);
+            if (parsedError) {
+              await this.writeToFile("ERROR", `  Error Message: ${parsedError}`);
+            }
+            await this.writeToFile("ERROR", `  Raw HTML: ${this.truncate(errorText, 1e3)}`);
+          } else {
+            const preview = this.truncate(errorText, 500);
+            await this.writeToFile("ERROR", `  Response: ${preview}`);
+          }
+        } else {
+          await this.writeToFile("ERROR", `  Response: (no data)`);
+        }
+      }
+      if (err && typeof err === "object" && "stack" in err && typeof err.stack === "string") {
+        const stackLines = err.stack.split("\n").slice(0, 5).join("\n    ");
+        await this.writeToFile("ERROR", `  Stack: ${stackLines}`);
+      } else if (err && typeof err === "object" && "message" in err && typeof err.message === "string") {
+        await this.writeToFile("ERROR", `  Message: ${err.message}`);
+      }
+    } catch (error) {
+    }
+  }
+  /**
+   * Safely stringify object, handling circular references
+   */
+  safeStringify(obj) {
+    try {
+      return JSON.stringify(obj);
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("circular")) {
+        try {
+          const seen = /* @__PURE__ */ new WeakSet();
+          return JSON.stringify(obj, (key, value) => {
+            if (typeof value === "object" && value !== null) {
+              if (seen.has(value)) {
+                return "[Circular]";
+              }
+              seen.add(value);
+            }
+            return value;
+          });
+        } catch {
+          return "[Unable to stringify]";
+        }
+      }
+      return "[Stringify error]";
+    }
+  }
+  /**
+   * Extract readable text from error response data
+   */
+  extractErrorMessage(data) {
+    if (Buffer.isBuffer(data)) {
+      return data.toString("utf-8");
+    }
+    if (typeof data === "string") {
+      return data;
+    }
+    if (data && typeof data === "object" && "_readableState" in data && data._readableState && typeof data._readableState === "object" && "buffer" in data._readableState && Array.isArray(data._readableState.buffer) && data._readableState.buffer.length > 0) {
+      const chunks = [];
+      for (const chunk of data._readableState.buffer) {
+        if (chunk && typeof chunk === "object" && "type" in chunk && chunk.type === "Buffer" && "data" in chunk && Array.isArray(chunk.data)) {
+          chunks.push(Buffer.from(chunk.data));
+        } else if (Buffer.isBuffer(chunk)) {
+          chunks.push(chunk);
+        } else if (chunk && typeof chunk === "object" && "data" in chunk) {
+          if (Buffer.isBuffer(chunk.data)) {
+            chunks.push(chunk.data);
+          } else if (Array.isArray(chunk.data)) {
+            chunks.push(Buffer.from(chunk.data));
+          }
+        }
+      }
+      if (chunks.length > 0) {
+        return Buffer.concat(chunks).toString("utf-8");
+      }
+    }
+    return this.safeStringify(data);
+  }
+  /**
+   * Parse HTML error page to extract error message
+   */
+  parseHtmlError(html) {
+    const titleMatch = html.match(/<title>(.*?)<\/title>/i);
+    const h1Match = html.match(/<h1>(.*?)<\/h1>/i);
+    const bodyMatch = html.match(/<body[^>]*>(.*?)<\/body>/is);
+    if (titleMatch && titleMatch[1] !== "Error") {
+      return titleMatch[1].trim();
+    }
+    if (h1Match) {
+      return h1Match[1].trim();
+    }
+    if (bodyMatch) {
+      const text = bodyMatch[1].replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
+      return text.substring(0, 200);
+    }
+    return null;
+  }
+  /**
+   * Truncate string to max length with ellipsis
+   */
+  truncate(str, maxLength) {
+    if (str.length <= maxLength) {
+      return str;
+    }
+    return str.substring(0, maxLength) + "... [truncated]";
+  }
+  /**
+   * Format bytes to human-readable size
+   */
+  formatBytes(bytes) {
+    if (bytes === 0) return "0 B";
+    const k = 1024;
+    const sizes = ["B", "KB", "MB", "GB"];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return Math.round(bytes / Math.pow(k, i) * 100) / 100 + " " + sizes[i];
+  }
+  /**
+   * Clean up old debug logs (older than 30 days)
+   */
+  async cleanupOldLogs() {
+    if (!this.fileLoggingEnabled) return;
+    try {
+      const debugDir = path12.join(os.homedir(), ".bike4mind", "debug");
+      const files = await fs10.readdir(debugDir);
+      const now = Date.now();
+      const thirtyDaysAgo = now - 30 * 24 * 60 * 60 * 1e3;
+      for (const file of files) {
+        const filePath = path12.join(debugDir, file);
+        const stats = await fs10.stat(filePath);
+        if (stats.mtime.getTime() < thirtyDaysAgo) {
+          await fs10.unlink(filePath);
+        }
+      }
+    } catch (error) {
+      console.error("Failed to cleanup old logs:", error);
+    }
+  }
+};
+var logger = Logger2.getInstance();
+
+// src/llm/ServerToolExecutor.ts
+var ServerToolExecutor = class {
+  constructor(apiClient) {
+    this.toolsEndpoint = "/api/ai/v1/tools";
+    this.apiClient = apiClient;
+  }
+  /**
+   * Execute a tool server-side
+   *
+   * @param toolName - Name of the tool to execute (e.g., 'weather_info', 'web_search')
+   * @param input - Tool input parameters
+   * @returns Tool execution result (content or error)
+   */
+  async executeTool(toolName, input) {
+    logger.debug(`[ServerToolExecutor] Executing tool: ${toolName}`);
+    logger.debug(`[ServerToolExecutor] Endpoint: ${this.toolsEndpoint}`);
+    logger.debug(`[ServerToolExecutor] Input: ${JSON.stringify(input)}`);
+    try {
+      const result = await this.apiClient.post(this.toolsEndpoint, {
+        toolName,
+        input
+      });
+      logger.debug(`[ServerToolExecutor] Response: ${JSON.stringify(result)}`);
+      if (!result.success) {
+        const errorMessage = result.error || "Tool execution failed";
+        logger.error(`[ServerToolExecutor] Tool ${toolName} failed: ${errorMessage}`);
+        return `Error executing ${toolName}: ${errorMessage}`;
+      }
+      logger.debug(`[ServerToolExecutor] Tool ${toolName} succeeded in ${result.executionTimeMs}ms`);
+      return result.content || "";
+    } catch (error) {
+      const err = error;
+      const errorMessage = err?.response?.data?.error || err?.message || "Unknown error";
+      const status = err?.response?.status || "unknown";
+      logger.error(`[ServerToolExecutor] Request failed for ${toolName}: ${errorMessage} (status: ${status})`);
+      logger.error(`[ServerToolExecutor] Full error: ${JSON.stringify(err, null, 2)}`);
+      return `Error executing ${toolName}: ${errorMessage}`;
+    }
+  }
+};
+
+// src/llm/ToolRouter.ts
+var SERVER_TOOLS = ["weather_info", "web_search"];
+var LOCAL_TOOLS = [
+  "file_read",
+  "create_file",
+  "glob_files",
+  "grep_search",
+  "delete_file",
+  "edit_file",
+  "dice_roll",
+  "math_evaluate",
+  "current_datetime"
+];
+function isServerTool(toolName) {
+  return SERVER_TOOLS.includes(toolName);
+}
+function isLocalTool(toolName) {
+  return LOCAL_TOOLS.includes(toolName);
+}
+async function executeTool(toolName, input, apiClient, localToolFn) {
+  if (isServerTool(toolName)) {
+    logger.debug(`[ToolRouter] Routing ${toolName} to server`);
+    const executor = new ServerToolExecutor(apiClient);
+    return await executor.executeTool(toolName, input);
+  } else if (isLocalTool(toolName)) {
+    logger.debug(`[ToolRouter] Executing ${toolName} locally`);
+    if (!localToolFn) {
+      throw new Error(`Local tool ${toolName} has no implementation`);
+    }
+    const result = await localToolFn(input);
+    return typeof result === "string" ? result : JSON.stringify(result);
+  } else {
+    throw new Error(`Unknown tool: ${toolName}`);
+  }
+}
+
 // src/utils/toolsAdapter.ts
 var NoOpStorage = class extends BaseStorage {
   async upload(input, destination, options) {
@@ -9272,14 +9615,14 @@ var CliLogger = class extends Logger {
   log(...args) {
   }
 };
-function wrapToolWithPermission(tool, permissionManager, showPermissionPrompt, agentContext, configStore) {
+function wrapToolWithPermission(tool, permissionManager, showPermissionPrompt, agentContext, configStore, apiClient) {
   const originalFn = tool.toolFn;
   const toolName = tool.toolSchema.name;
   return {
     ...tool,
     toolFn: async (args) => {
       if (!permissionManager.needsPermission(toolName)) {
-        const result2 = await originalFn(args);
+        const result2 = await executeTool(toolName, args, apiClient, originalFn);
         agentContext.observationQueue.push({ toolName, result: result2 });
         return result2;
       }
@@ -9340,13 +9683,13 @@ function wrapToolWithPermission(tool, permissionManager, showPermissionPrompt, a
           }
         }
       }
-      const result = await originalFn(args);
+      const result = await executeTool(toolName, args, apiClient, originalFn);
       agentContext.observationQueue.push({ toolName, result });
       return result;
     }
   };
 }
-function generateCliTools(userId, llm, model, permissionManager, showPermissionPrompt, agentContext, configStore, toolApiKeys) {
+function generateCliTools(userId, llm, model, permissionManager, showPermissionPrompt, agentContext, configStore, apiClient) {
   const logger2 = new CliLogger();
   const storage = new NoOpStorage();
   const user = {
@@ -9363,18 +9706,6 @@ function generateCliTools(userId, llm, model, permissionManager, showPermissionP
   };
   const mockAdminSettings = {
     findBySettingName: async (settingName) => {
-      if (settingName === "OpenWeatherKey") {
-        const key = toolApiKeys?.openweather || process.env.OPENWEATHER_API_KEY;
-        if (key) {
-          return { settingValue: key };
-        }
-      }
-      if (settingName === "SerperKey") {
-        const key = toolApiKeys?.serper || process.env.SERPER_API_KEY;
-        if (key) {
-          return { settingValue: key };
-        }
-      }
       return null;
     }
   };
@@ -9384,15 +9715,13 @@ function generateCliTools(userId, llm, model, permissionManager, showPermissionP
       adminSettings: mockAdminSettings
     }
   };
-  const hasSerperKey = !!(toolApiKeys?.serper || process.env.SERPER_API_KEY);
-  const hasOpenWeatherKey = !!(toolApiKeys?.openweather || process.env.OPENWEATHER_API_KEY);
   const toolConfig = {
-    // Enable these tools for CLI (no external API keys needed)
+    // Local-only tools (no external API keys needed)
     dice_roll: {},
     math_evaluate: {},
     current_datetime: {},
     prompt_enhancement: {},
-    // File operation tools (CLI-specific)
+    // File operation tools (CLI-specific, local execution)
     file_read: {},
     create_file: {},
     glob_files: {},
@@ -9400,13 +9729,10 @@ function generateCliTools(userId, llm, model, permissionManager, showPermissionP
     delete_file: {},
     // Shell execution (always requires permission)
     bash_execute: {},
-    // Tools requiring API keys (only include if API key is available)
-    ...hasSerperKey && { web_search: {} },
-    // Requires SERPER_API_KEY
-    ...hasOpenWeatherKey && { weather_info: {} },
-    // Requires OPENWEATHER_API_KEY
-    ...hasSerperKey && { deep_research: {} }
-    // Requires SERPER_API_KEY
+    // Server-side tools (executed via /api/ai/v1/tools Lambda)
+    // Routed by ToolRouter to use B4M company API keys
+    weather_info: {},
+    web_search: {}
     // Disable web-only tools
     // blog_publish: undefined,
     // blog_edit: undefined,
@@ -9416,6 +9742,7 @@ function generateCliTools(userId, llm, model, permissionManager, showPermissionP
     // mermaid_chart: undefined,
     // recharts: undefined,
     // edit_file: undefined,
+    // deep_research: undefined,
   };
   const toolsMap = generateTools(
     userId,
@@ -9433,7 +9760,7 @@ function generateCliTools(userId, llm, model, permissionManager, showPermissionP
     model
   );
   const tools2 = Object.entries(toolsMap).filter(([key]) => toolConfig[key] !== void 0).map(
-    ([_, tool]) => wrapToolWithPermission(tool, permissionManager, showPermissionPrompt, agentContext, configStore)
+    ([_, tool]) => wrapToolWithPermission(tool, permissionManager, showPermissionPrompt, agentContext, configStore, apiClient)
   );
   return { tools: tools2, agentContext };
 }
@@ -9629,261 +9956,6 @@ function getEnvironmentName(configApiConfig) {
   return "Bike4Mind";
 }
 
-// src/utils/Logger.ts
-import fs10 from "fs/promises";
-import path12 from "path";
-import os from "os";
-var Logger2 = class _Logger {
-  constructor() {
-    this.logFilePath = null;
-    this.sessionId = null;
-    this.fileLoggingEnabled = true;
-    this.consoleVerbose = false;
-  }
-  static {
-    this.instance = null;
-  }
-  static getInstance() {
-    if (!_Logger.instance) {
-      _Logger.instance = new _Logger();
-    }
-    return _Logger.instance;
-  }
-  /**
-   * Initialize the logger with a session ID
-   */
-  async initialize(sessionId) {
-    this.sessionId = sessionId;
-    const debugDir = path12.join(os.homedir(), ".bike4mind", "debug");
-    await fs10.mkdir(debugDir, { recursive: true });
-    this.logFilePath = path12.join(debugDir, `${sessionId}.txt`);
-    await this.writeToFile("INFO", "=== CLI SESSION START ===");
-  }
-  /**
-   * Set whether verbose console logging is enabled
-   */
-  setVerbose(enabled) {
-    this.consoleVerbose = enabled;
-  }
-  /**
-   * Set whether file logging is enabled
-   */
-  setFileLoggingEnabled(enabled) {
-    this.fileLoggingEnabled = enabled;
-  }
-  /**
-   * DEBUG level - verbose-only console, always file
-   */
-  debug(message) {
-    this.writeToFile("DEBUG", message).catch(() => {
-    });
-    if (this.consoleVerbose) {
-      console.log(message);
-    }
-  }
-  /**
-   * INFO level - always shown to user
-   */
-  info(message) {
-    this.writeToFile("INFO", message).catch(() => {
-    });
-    console.log(message);
-  }
-  /**
-   * WARN level - always shown to user
-   */
-  warn(message) {
-    this.writeToFile("WARN", message).catch(() => {
-    });
-    console.warn(message);
-  }
-  /**
-   * ERROR level - always shown to user
-   */
-  error(message, err) {
-    this.writeToFile("ERROR", message).catch(() => {
-    });
-    if (err) {
-      this.logErrorDetailsToFile(err).catch(() => {
-      });
-    }
-    console.error(message);
-  }
-  /**
-   * Write log entry to file
-   */
-  async writeToFile(level, message) {
-    if (!this.fileLoggingEnabled || !this.logFilePath) {
-      return;
-    }
-    try {
-      const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").substring(0, 19);
-      const logEntry = `[${timestamp}] [${level}] ${message}
-`;
-      await fs10.appendFile(this.logFilePath, logEntry, "utf-8");
-    } catch (error) {
-      console.error("File logging failed:", error);
-    }
-  }
-  /**
-   * Log error details to file
-   */
-  async logErrorDetailsToFile(err) {
-    if (!this.fileLoggingEnabled || !this.logFilePath) {
-      return;
-    }
-    try {
-      if (err && typeof err === "object" && "response" in err && err.response) {
-        const response = err.response;
-        const config = err && typeof err === "object" && "config" in err ? err.config : void 0;
-        await this.writeToFile("ERROR", `  Status: ${response.status} ${response.statusText || ""}`);
-        await this.writeToFile("ERROR", `  URL: ${config?.url || "unknown"}`);
-        await this.writeToFile("ERROR", `  Headers: ${this.safeStringify(response.headers)}`);
-        if (response.data) {
-          const errorText = this.extractErrorMessage(response.data);
-          if (errorText.trim().startsWith("<!DOCTYPE") || errorText.trim().startsWith("<html")) {
-            await this.writeToFile("ERROR", `  Response Type: HTML Error Page`);
-            const parsedError = this.parseHtmlError(errorText);
-            if (parsedError) {
-              await this.writeToFile("ERROR", `  Error Message: ${parsedError}`);
-            }
-            await this.writeToFile("ERROR", `  Raw HTML: ${this.truncate(errorText, 1e3)}`);
-          } else {
-            const preview = this.truncate(errorText, 500);
-            await this.writeToFile("ERROR", `  Response: ${preview}`);
-          }
-        } else {
-          await this.writeToFile("ERROR", `  Response: (no data)`);
-        }
-      }
-      if (err && typeof err === "object" && "stack" in err && typeof err.stack === "string") {
-        const stackLines = err.stack.split("\n").slice(0, 5).join("\n    ");
-        await this.writeToFile("ERROR", `  Stack: ${stackLines}`);
-      } else if (err && typeof err === "object" && "message" in err && typeof err.message === "string") {
-        await this.writeToFile("ERROR", `  Message: ${err.message}`);
-      }
-    } catch (error) {
-    }
-  }
-  /**
-   * Safely stringify object, handling circular references
-   */
-  safeStringify(obj) {
-    try {
-      return JSON.stringify(obj);
-    } catch (error) {
-      if (error instanceof Error && error.message.includes("circular")) {
-        try {
-          const seen = /* @__PURE__ */ new WeakSet();
-          return JSON.stringify(obj, (key, value) => {
-            if (typeof value === "object" && value !== null) {
-              if (seen.has(value)) {
-                return "[Circular]";
-              }
-              seen.add(value);
-            }
-            return value;
-          });
-        } catch {
-          return "[Unable to stringify]";
-        }
-      }
-      return "[Stringify error]";
-    }
-  }
-  /**
-   * Extract readable text from error response data
-   */
-  extractErrorMessage(data) {
-    if (Buffer.isBuffer(data)) {
-      return data.toString("utf-8");
-    }
-    if (typeof data === "string") {
-      return data;
-    }
-    if (data && typeof data === "object" && "_readableState" in data && data._readableState && typeof data._readableState === "object" && "buffer" in data._readableState && Array.isArray(data._readableState.buffer) && data._readableState.buffer.length > 0) {
-      const chunks = [];
-      for (const chunk of data._readableState.buffer) {
-        if (chunk && typeof chunk === "object" && "type" in chunk && chunk.type === "Buffer" && "data" in chunk && Array.isArray(chunk.data)) {
-          chunks.push(Buffer.from(chunk.data));
-        } else if (Buffer.isBuffer(chunk)) {
-          chunks.push(chunk);
-        } else if (chunk && typeof chunk === "object" && "data" in chunk) {
-          if (Buffer.isBuffer(chunk.data)) {
-            chunks.push(chunk.data);
-          } else if (Array.isArray(chunk.data)) {
-            chunks.push(Buffer.from(chunk.data));
-          }
-        }
-      }
-      if (chunks.length > 0) {
-        return Buffer.concat(chunks).toString("utf-8");
-      }
-    }
-    return this.safeStringify(data);
-  }
-  /**
-   * Parse HTML error page to extract error message
-   */
-  parseHtmlError(html) {
-    const titleMatch = html.match(/<title>(.*?)<\/title>/i);
-    const h1Match = html.match(/<h1>(.*?)<\/h1>/i);
-    const bodyMatch = html.match(/<body[^>]*>(.*?)<\/body>/is);
-    if (titleMatch && titleMatch[1] !== "Error") {
-      return titleMatch[1].trim();
-    }
-    if (h1Match) {
-      return h1Match[1].trim();
-    }
-    if (bodyMatch) {
-      const text = bodyMatch[1].replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
-      return text.substring(0, 200);
-    }
-    return null;
-  }
-  /**
-   * Truncate string to max length with ellipsis
-   */
-  truncate(str, maxLength) {
-    if (str.length <= maxLength) {
-      return str;
-    }
-    return str.substring(0, maxLength) + "... [truncated]";
-  }
-  /**
-   * Format bytes to human-readable size
-   */
-  formatBytes(bytes) {
-    if (bytes === 0) return "0 B";
-    const k = 1024;
-    const sizes = ["B", "KB", "MB", "GB"];
-    const i = Math.floor(Math.log(bytes) / Math.log(k));
-    return Math.round(bytes / Math.pow(k, i) * 100) / 100 + " " + sizes[i];
-  }
-  /**
-   * Clean up old debug logs (older than 30 days)
-   */
-  async cleanupOldLogs() {
-    if (!this.fileLoggingEnabled) return;
-    try {
-      const debugDir = path12.join(os.homedir(), ".bike4mind", "debug");
-      const files = await fs10.readdir(debugDir);
-      const now = Date.now();
-      const thirtyDaysAgo = now - 30 * 24 * 60 * 60 * 1e3;
-      for (const file of files) {
-        const filePath = path12.join(debugDir, file);
-        const stats = await fs10.stat(filePath);
-        if (stats.mtime.getTime() < thirtyDaysAgo) {
-          await fs10.unlink(filePath);
-        }
-      }
-    } catch (error) {
-      console.error("Failed to cleanup old logs:", error);
-    }
-  }
-};
-var logger = Logger2.getInstance();
-
 // ../../b4m-core/packages/mcp/dist/src/client.js
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { Client as Client2 } from "@modelcontextprotocol/sdk/client/index.js";
@@ -10687,7 +10759,10 @@ var ApiClient = class {
    * Make a POST request
    */
   async post(url, data, config) {
+    logger.debug(`[ApiClient] POST ${this.client.defaults.baseURL}${url}`);
+    logger.debug(`[ApiClient] Request body: ${JSON.stringify(data)}`);
     const response = await this.client.post(url, data, config);
+    logger.debug(`[ApiClient] Response status: ${response.status}`);
     return response.data;
   }
   /**
@@ -10738,7 +10813,7 @@ import { isAxiosError as isAxiosError2 } from "axios";
 // package.json
 var package_default = {
   name: "@bike4mind/cli",
-  version: "0.2.8-cli-bash-tools.17140+f678d9888",
+  version: "0.2.8-cli-bash-tools.17146+9129ce1ea",
   type: "module",
   description: "Interactive CLI tool for Bike4Mind with ReAct agents",
   license: "UNLICENSED",
@@ -10841,10 +10916,10 @@ var package_default = {
   },
   devDependencies: {
     "@bike4mind/agents": "0.1.0",
-    "@bike4mind/common": "2.38.2-cli-bash-tools.17140+f678d9888",
-    "@bike4mind/mcp": "1.20.2-cli-bash-tools.17140+f678d9888",
-    "@bike4mind/services": "2.33.2-cli-bash-tools.17140+f678d9888",
-    "@bike4mind/utils": "2.1.3-cli-bash-tools.17140+f678d9888",
+    "@bike4mind/common": "2.38.2-cli-bash-tools.17146+9129ce1ea",
+    "@bike4mind/mcp": "1.20.2-cli-bash-tools.17146+9129ce1ea",
+    "@bike4mind/services": "2.33.2-cli-bash-tools.17146+9129ce1ea",
+    "@bike4mind/utils": "2.1.3-cli-bash-tools.17146+9129ce1ea",
     "@types/better-sqlite3": "^7.6.12",
     "@types/diff": "^5.0.9",
     "@types/jsonwebtoken": "^9.0.4",
@@ -10857,7 +10932,7 @@ var package_default = {
     typescript: "^5.9.3",
     vitest: "^3.2.4"
   },
-  gitHead: "f678d98888d841ba0496d91a1225dd89edb21e35"
+  gitHead: "9129ce1ea5d8589dec80ac92bf32ca954c6844fc"
 };
 
 // src/config/constants.ts
@@ -11082,10 +11157,6 @@ function CliApp() {
           setPermissionPrompt(prompt);
         });
       };
-      console.log("\u{1F511} Tool API Keys:", {
-        openweather: config.toolApiKeys?.openweather ? "\u2713 configured" : "\u2717 missing",
-        serper: config.toolApiKeys?.serper ? "\u2713 configured" : "\u2717 missing"
-      });
       const agentContext = {
         currentAgent: null,
         observationQueue: []
@@ -11098,7 +11169,7 @@ function CliApp() {
         promptFn,
         agentContext,
         state.configStore,
-        config.toolApiKeys
+        apiClient
       );
       console.log(`\u{1F6E0}\uFE0F  Loaded ${b4mTools.length} B4M tool(s)`);
       const mcpManager = new McpManager(config);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bike4mind/cli",
-  "version": "0.2.8-cli-bash-tools.17140+f678d9888",
+  "version": "0.2.8-cli-bash-tools.17146+9129ce1ea",
   "type": "module",
   "description": "Interactive CLI tool for Bike4Mind with ReAct agents",
   "license": "UNLICENSED",
@@ -103,10 +103,10 @@
   },
   "devDependencies": {
     "@bike4mind/agents": "0.1.0",
-    "@bike4mind/common": "2.38.2-cli-bash-tools.17140+f678d9888",
-    "@bike4mind/mcp": "1.20.2-cli-bash-tools.17140+f678d9888",
-    "@bike4mind/services": "2.33.2-cli-bash-tools.17140+f678d9888",
-    "@bike4mind/utils": "2.1.3-cli-bash-tools.17140+f678d9888",
+    "@bike4mind/common": "2.38.2-cli-bash-tools.17146+9129ce1ea",
+    "@bike4mind/mcp": "1.20.2-cli-bash-tools.17146+9129ce1ea",
+    "@bike4mind/services": "2.33.2-cli-bash-tools.17146+9129ce1ea",
+    "@bike4mind/utils": "2.1.3-cli-bash-tools.17146+9129ce1ea",
     "@types/better-sqlite3": "^7.6.12",
     "@types/diff": "^5.0.9",
     "@types/jsonwebtoken": "^9.0.4",
@@ -119,5 +119,5 @@
     "typescript": "^5.9.3",
     "vitest": "^3.2.4"
   },
-  "gitHead": "f678d98888d841ba0496d91a1225dd89edb21e35"
+  "gitHead": "9129ce1ea5d8589dec80ac92bf32ca954c6844fc"
 }