@bike4mind/cli 0.2.29-cli-minimal-ui.18782 → 0.2.29-cli-minimal-ui.18783

package/dist/{chunk-23T2XGSZ.js → chunk-LBTTUQJM.js}

@@ -1,8 +1,264 @@
 #!/usr/bin/env node
 
-// src/storage/ConfigStore.ts
-import { promises as fs, existsSync } from "fs";
+// src/utils/Logger.ts
+import fs from "fs/promises";
 import path from "path";
+import os from "os";
+var Logger = 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 = path.join(os.homedir(), ".bike4mind", "debug");
+    await fs.mkdir(debugDir, { recursive: true });
+    this.logFilePath = path.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 fs.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 = path.join(os.homedir(), ".bike4mind", "debug");
+      const files = await fs.readdir(debugDir);
+      const now = Date.now();
+      const thirtyDaysAgo = now - 30 * 24 * 60 * 60 * 1e3;
+      for (const file of files) {
+        const filePath = path.join(debugDir, file);
+        const stats = await fs.stat(filePath);
+        if (stats.mtime.getTime() < thirtyDaysAgo) {
+          await fs.unlink(filePath);
+        }
+      }
+    } catch (error) {
+      console.error("Failed to cleanup old logs:", error);
+    }
+  }
+};
+var logger = Logger.getInstance();
+logger.setVerbose(process.env.B4M_VERBOSE === "1");
+
+// src/storage/ConfigStore.ts
+import { promises as fs2, existsSync } from "fs";
+import path2 from "path";
 import { homedir } from "os";
 import { v4 as uuidv4 } from "uuid";
 import { z } from "zod";
@@ -147,23 +403,23 @@ var DEFAULT_CONFIG = {
 };
 function findProjectConfigDir(startDir = process.cwd()) {
   let currentDir = startDir;
-  const { root } = path.parse(currentDir);
+  const { root } = path2.parse(currentDir);
   while (currentDir !== root) {
-    const gitPath = path.join(currentDir, ".git");
+    const gitPath = path2.join(currentDir, ".git");
     try {
       if (existsSync(gitPath)) {
         return currentDir;
       }
     } catch {
     }
-    currentDir = path.dirname(currentDir);
+    currentDir = path2.dirname(currentDir);
   }
   return process.cwd();
 }
 async function loadProjectConfig(projectDir) {
-  const configPath = path.join(projectDir, ".bike4mind", "config.json");
+  const configPath = path2.join(projectDir, ".bike4mind", "config.json");
   try {
-    const data = await fs.readFile(configPath, "utf-8");
+    const data = await fs2.readFile(configPath, "utf-8");
     const rawConfig = JSON.parse(data);
     const validated = ProjectConfigSchema.parse(rawConfig);
     const result = {
@@ -184,9 +440,9 @@ async function loadProjectConfig(projectDir) {
   }
 }
 async function loadProjectLocalConfig(projectDir) {
-  const configPath = path.join(projectDir, ".bike4mind", "local.json");
+  const configPath = path2.join(projectDir, ".bike4mind", "local.json");
   try {
-    const data = await fs.readFile(configPath, "utf-8");
+    const data = await fs2.readFile(configPath, "utf-8");
     const rawConfig = JSON.parse(data);
     const validated = ProjectLocalConfigSchema.parse(rawConfig);
     const result = {
@@ -210,9 +466,9 @@ var McpJsonConfigSchema = z.object({
   mcpServers: McpServersSchema
 });
 async function loadMcpJsonConfig(projectDir) {
-  const mcpConfigPath = path.join(projectDir, ".mcp.json");
+  const mcpConfigPath = path2.join(projectDir, ".mcp.json");
   try {
-    const data = await fs.readFile(mcpConfigPath, "utf-8");
+    const data = await fs2.readFile(mcpConfigPath, "utf-8");
     const rawConfig = JSON.parse(data);
     const validated = McpJsonConfigSchema.parse(rawConfig);
     const servers = normalizeMcpServers(validated.mcpServers);
@@ -294,15 +550,15 @@ var ConfigStore = class {
   constructor(configPath) {
     this.config = null;
     this.projectConfigDir = null;
-    this.configPath = configPath || path.join(homedir(), ".bike4mind", "config.json");
+    this.configPath = configPath || path2.join(homedir(), ".bike4mind", "config.json");
   }
   /**
    * Initialize config directory
    */
   async init() {
-    const dir = path.dirname(this.configPath);
+    const dir = path2.dirname(this.configPath);
     try {
-      await fs.mkdir(dir, { recursive: true });
+      await fs2.mkdir(dir, { recursive: true });
     } catch (error) {
       console.error("Failed to initialize config directory:", error);
       throw error;
@@ -320,15 +576,15 @@ var ConfigStore = class {
       let globalConfig;
       try {
         try {
-          const stats = await fs.stat(this.configPath);
+          const stats = await fs2.stat(this.configPath);
           const mode = stats.mode & 511;
           if (mode !== 384) {
             console.warn(`\u26A0\uFE0F  Config file has insecure permissions (${mode.toString(8)}). Setting to 0600...`);
-            await fs.chmod(this.configPath, 384);
+            await fs2.chmod(this.configPath, 384);
           }
         } catch (statError) {
         }
-        const data = await fs.readFile(this.configPath, "utf-8");
+        const data = await fs2.readFile(this.configPath, "utf-8");
         const rawConfig = JSON.parse(data);
         if (rawConfig.apiConfig && "environment" in rawConfig.apiConfig) {
           const oldApiConfig = rawConfig.apiConfig;
@@ -381,10 +637,10 @@ var ConfigStore = class {
           projectLocalConfig = await loadProjectLocalConfig(this.projectConfigDir);
           mcpJsonServers = await loadMcpJsonConfig(this.projectConfigDir);
           if (projectConfig) {
-            console.log(`\u{1F4C1} Project config loaded from: ${this.projectConfigDir}/.bike4mind/`);
+            logger.debug(`\u{1F4C1} Project config loaded from: ${this.projectConfigDir}/.bike4mind/`);
           }
           if (mcpJsonServers && mcpJsonServers.length > 0) {
-            console.log(`\u{1F4C1} Project MCP config loaded from: ${this.projectConfigDir}/.mcp.json`);
+            logger.debug(`\u{1F4C1} Project MCP config loaded from: ${this.projectConfigDir}/.mcp.json`);
           }
         }
       } else {
@@ -438,8 +694,8 @@ var ConfigStore = class {
       throw new Error("No configuration to save");
     }
     try {
-      await fs.writeFile(this.configPath, JSON.stringify(this.config, null, 2), "utf-8");
-      await fs.chmod(this.configPath, 384);
+      await fs2.writeFile(this.configPath, JSON.stringify(this.config, null, 2), "utf-8");
+      await fs2.chmod(this.configPath, 384);
     } catch (error) {
       console.error("Failed to save config:", error);
       throw error;
@@ -599,20 +855,20 @@ var ConfigStore = class {
     if (!projectDir) {
       return;
     }
-    const configDir = path.join(projectDir, ".bike4mind");
-    await fs.mkdir(configDir, { recursive: true });
+    const configDir = path2.join(projectDir, ".bike4mind");
+    await fs2.mkdir(configDir, { recursive: true });
     await this.ensureGitignore(projectDir);
   }
   /**
    * Ensure .gitignore includes .bike4mind/local.json
    */
   async ensureGitignore(projectDir) {
-    const gitignorePath = path.join(projectDir, ".gitignore");
+    const gitignorePath = path2.join(projectDir, ".gitignore");
     const entryToAdd = ".bike4mind/local.json";
     try {
       let gitignoreContent = "";
       try {
-        gitignoreContent = await fs.readFile(gitignorePath, "utf-8");
+        gitignoreContent = await fs2.readFile(gitignorePath, "utf-8");
       } catch {
       }
       if (gitignoreContent.includes(entryToAdd)) {
@@ -622,7 +878,7 @@ var ConfigStore = class {
 # Bike4Mind local config (developer-specific)
 ${entryToAdd}
 `;
-      await fs.writeFile(gitignorePath, newContent, "utf-8");
+      await fs2.writeFile(gitignorePath, newContent, "utf-8");
       console.log(`\u2705 Added ${entryToAdd} to .gitignore`);
     } catch (error) {
       console.warn(`\u26A0\uFE0F  Failed to update .gitignore:`, error);
@@ -633,10 +889,10 @@ ${entryToAdd}
    */
   async saveProjectConfig(config, projectDir) {
     const targetDir = projectDir || this.projectConfigDir || process.cwd();
-    const configPath = path.join(targetDir, ".bike4mind", "config.json");
-    await fs.mkdir(path.dirname(configPath), { recursive: true });
+    const configPath = path2.join(targetDir, ".bike4mind", "config.json");
+    await fs2.mkdir(path2.dirname(configPath), { recursive: true });
     const validated = ProjectConfigSchema.parse(config);
-    await fs.writeFile(configPath, JSON.stringify(validated, null, 2), "utf-8");
+    await fs2.writeFile(configPath, JSON.stringify(validated, null, 2), "utf-8");
     console.log(`\u2705 Saved project config to: ${configPath}`);
   }
   /**
@@ -644,11 +900,11 @@ ${entryToAdd}
    */
   async saveProjectLocalConfig(config, projectDir) {
     const targetDir = projectDir || this.projectConfigDir || process.cwd();
-    const configPath = path.join(targetDir, ".bike4mind", "local.json");
-    await fs.mkdir(path.dirname(configPath), { recursive: true });
+    const configPath = path2.join(targetDir, ".bike4mind", "local.json");
+    await fs2.mkdir(path2.dirname(configPath), { recursive: true });
     const validated = ProjectLocalConfigSchema.parse(config);
-    await fs.writeFile(configPath, JSON.stringify(validated, null, 2), "utf-8");
-    await fs.chmod(configPath, 384);
+    await fs2.writeFile(configPath, JSON.stringify(validated, null, 2), "utf-8");
+    await fs2.chmod(configPath, 384);
     console.log(`\u2705 Saved project-local config to: ${configPath}`);
   }
   /**
@@ -672,5 +928,6 @@ ${entryToAdd}
 };
 
 export {
+  logger,
   ConfigStore
 };

package/dist/commands/mcpCommand.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   ConfigStore
-} from "../chunk-23T2XGSZ.js";
+} from "../chunk-LBTTUQJM.js";
 
 // src/commands/mcpCommand.ts
 async function handleMcpCommand(subcommand, argv) {