@bike4mind/cli 0.2.28 → 0.2.29-chore-upgrade-zod4.18830

package/README.md

@@ -101,7 +101,7 @@ While in interactive mode:
 
 **Session Management:**
 - `/save <name>` - Save current session
-- `/sessions` - List saved sessions
+- `/resume` - List and resume saved sessions
 
 **API Configuration:**
 - `/set-api <url>` - Connect to self-hosted Bike4Mind instance

package/dist/{artifactExtractor-36XHJYOZ.js → artifactExtractor-27P4HWVG.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   CurationArtifactType
-} from "./chunk-XJRPAAUS.js";
+} from "./chunk-BWPGS3D5.js";
 
 // ../../b4m-core/packages/services/dist/src/notebookCurationService/artifactExtractor.js
 var ARTIFACT_TAG_REGEX = /<artifact\s+(.*?)>([\s\S]*?)<\/artifact>/gi;

package/dist/{chunk-23T2XGSZ.js → chunk-32PKF3N7.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";
@@ -13,24 +269,25 @@ var AuthTokensSchema = z.object({
   userId: z.string()
 });
 var ApiConfigSchema = z.object({
-  customUrl: z.string().url().optional()
+  customUrl: z.url().optional()
 });
 var McpServerSchema = z.object({
   name: z.string(),
   command: z.string().optional(),
   args: z.array(z.string()).optional(),
-  env: z.record(z.string()).default({}),
-  enabled: z.boolean().default(true)
+  env: z.record(z.string(), z.string()).prefault({}),
+  enabled: z.boolean().prefault(true)
 });
 var McpServersSchema = z.union([
   // Array format (B4M native)
   z.array(McpServerSchema),
   // Object format (portable - compatible with Claude Code)
   z.record(
+    z.string(),
     z.object({
       command: z.string().optional(),
       args: z.array(z.string()).optional(),
-      env: z.record(z.string()).optional(),
+      env: z.record(z.string(), z.string()).optional(),
       enabled: z.boolean().optional()
     })
   )
@@ -69,24 +326,24 @@ var CliConfigSchema = z.object({
     maxTokens: z.number(),
     temperature: z.number(),
     autoSave: z.boolean(),
-    autoCompact: z.boolean().optional().default(true),
+    autoCompact: z.boolean().optional().prefault(true),
     theme: z.enum(["light", "dark"]),
     exportFormat: z.enum(["markdown", "json"]),
-    maxIterations: z.number().nullable().default(10),
-    enableSkillTool: z.boolean().optional().default(true)
+    maxIterations: z.number().nullable().prefault(10),
+    enableSkillTool: z.boolean().optional().prefault(true)
   }),
   tools: z.object({
     enabled: z.array(z.string()),
     disabled: z.array(z.string()),
-    config: z.record(z.any())
+    config: z.record(z.string(), z.any())
   }),
-  trustedTools: z.array(z.string()).optional().default([])
+  trustedTools: z.array(z.string()).optional().prefault([])
 });
 var ProjectConfigSchema = z.object({
   tools: z.object({
     enabled: z.array(z.string()).optional(),
     denied: z.array(z.string()).optional(),
-    config: z.record(z.any()).optional()
+    config: z.record(z.string(), z.any()).optional()
   }).optional(),
   defaultModel: z.string().optional(),
   mcpServers: McpServersSchema.optional(),
@@ -147,23 +404,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 = {
@@ -176,7 +433,7 @@ async function loadProjectConfig(projectDir) {
       return null;
     }
     if (error instanceof z.ZodError) {
-      console.error("Project config validation error:", error.errors);
+      console.error("Project config validation error:", error.issues);
       return null;
     }
     console.error("Failed to load project config:", error);
@@ -184,9 +441,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 = {
@@ -199,7 +456,7 @@ async function loadProjectLocalConfig(projectDir) {
       return null;
     }
     if (error instanceof z.ZodError) {
-      console.error("Project local config validation error:", error.errors);
+      console.error("Project local config validation error:", error.issues);
       return null;
     }
     console.error("Failed to load project local config:", error);
@@ -210,9 +467,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);
@@ -222,7 +479,7 @@ async function loadMcpJsonConfig(projectDir) {
       return null;
     }
     if (error instanceof z.ZodError) {
-      console.error(".mcp.json validation error:", error.errors);
+      console.error(".mcp.json validation error:", error.issues);
       return null;
     }
     console.error("Failed to load .mcp.json:", error);
@@ -294,15 +551,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 +577,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;
@@ -364,7 +621,7 @@ var ConfigStore = class {
         if (error.code === "ENOENT") {
           globalConfig = { ...DEFAULT_CONFIG };
         } else if (error instanceof z.ZodError) {
-          console.error("Global config validation error:", error.errors);
+          console.error("Global config validation error:", error.issues);
           console.error("Using default configuration");
           globalConfig = { ...DEFAULT_CONFIG };
         } else {
@@ -381,10 +638,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 {
@@ -401,7 +658,7 @@ var ConfigStore = class {
         return this.reset();
       }
       if (error instanceof z.ZodError) {
-        console.error("Config validation error:", error.errors);
+        console.error("Config validation error:", error.issues);
         console.error("Resetting to default configuration");
         return this.reset();
       }
@@ -438,8 +695,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 +856,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 +879,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 +890,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 +901,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 +929,6 @@ ${entryToAdd}
 };
 
 export {
+  logger,
   ConfigStore
 };

package/dist/{chunk-ZEMWV6IR.js → chunk-5N5BUX3M.js}

@@ -7,11 +7,11 @@ import {
   getSettingsMap,
   getSettingsValue,
   secureParameters
-} from "./chunk-UNOJBVD2.js";
+} from "./chunk-W3S2VCLO.js";
 import {
   KnowledgeType,
   SupportedFabFileMimeTypes
-} from "./chunk-XJRPAAUS.js";
+} from "./chunk-BWPGS3D5.js";
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/create.js
 import { z } from "zod";
@@ -20,7 +20,7 @@ var createFabFileSchema = z.object({
   fileName: z.string(),
   mimeType: z.string(),
   fileSize: z.number(),
-  type: z.nativeEnum(KnowledgeType),
+  type: z.enum(KnowledgeType),
   content: z.union([z.string(), z.instanceof(Buffer)]).optional(),
   organizationId: z.string().optional(),
   /**