@bike4mind/cli 0.2.13 → 0.2.14-feat-cli-mcp-management.17477

package/dist/chunk-FFJX3FF3.js

@@ -0,0 +1,611 @@
+#!/usr/bin/env node
+
+// src/storage/ConfigStore.ts
+import { promises as fs, existsSync } from "fs";
+import path from "path";
+import { homedir } from "os";
+import { v4 as uuidv4 } from "uuid";
+import { z } from "zod";
+var AuthTokensSchema = z.object({
+  accessToken: z.string(),
+  refreshToken: z.string(),
+  expiresAt: z.string(),
+  userId: z.string()
+});
+var ApiConfigSchema = z.object({
+  customUrl: z.string().url().optional()
+});
+var CliConfigSchema = z.object({
+  version: z.string(),
+  userId: z.string(),
+  auth: AuthTokensSchema.optional(),
+  defaultModel: z.string(),
+  apiConfig: ApiConfigSchema.optional(),
+  toolApiKeys: z.object({
+    openweather: z.string().optional(),
+    serper: z.string().optional()
+  }).optional(),
+  mcpServers: z.array(
+    z.object({
+      name: z.string(),
+      command: z.string().optional(),
+      args: z.array(z.string()).optional(),
+      env: z.record(z.string()),
+      enabled: z.boolean()
+    })
+  ),
+  preferences: z.object({
+    maxTokens: z.number(),
+    temperature: z.number(),
+    autoSave: z.boolean(),
+    theme: z.enum(["light", "dark"]),
+    exportFormat: z.enum(["markdown", "json"]),
+    maxIterations: z.number().nullable().default(10)
+  }),
+  tools: z.object({
+    enabled: z.array(z.string()),
+    disabled: z.array(z.string()),
+    config: z.record(z.any())
+  }),
+  trustedTools: z.array(z.string()).optional().default([])
+});
+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()
+  }).optional(),
+  defaultModel: z.string().optional(),
+  mcpServers: z.array(
+    z.object({
+      name: z.string(),
+      command: z.string().optional(),
+      args: z.array(z.string()).optional(),
+      env: z.record(z.string()),
+      enabled: z.boolean()
+    })
+  ).optional(),
+  preferences: z.object({
+    maxTokens: z.number().optional(),
+    temperature: z.number().optional(),
+    autoSave: z.boolean().optional(),
+    theme: z.enum(["light", "dark"]).optional(),
+    exportFormat: z.enum(["markdown", "json"]).optional()
+  }).optional()
+});
+var ProjectLocalConfigSchema = z.object({
+  trustedTools: z.array(z.string()).optional(),
+  toolApiKeys: z.object({
+    openweather: z.string().optional(),
+    serper: z.string().optional()
+  }).optional(),
+  preferences: z.object({
+    maxTokens: z.number().optional(),
+    temperature: z.number().optional(),
+    autoSave: z.boolean().optional(),
+    theme: z.enum(["light", "dark"]).optional(),
+    exportFormat: z.enum(["markdown", "json"]).optional()
+  }).optional(),
+  mcpServers: z.array(
+    z.object({
+      name: z.string(),
+      command: z.string().optional(),
+      args: z.array(z.string()).optional(),
+      env: z.record(z.string()),
+      enabled: z.boolean()
+    })
+  ).optional()
+});
+var DEFAULT_CONFIG = {
+  version: "0.1.0",
+  userId: uuidv4(),
+  defaultModel: "claude-sonnet-4-5-20250929",
+  toolApiKeys: {
+    openweather: void 0,
+    serper: void 0
+  },
+  mcpServers: [],
+  preferences: {
+    maxTokens: 4096,
+    temperature: 0.7,
+    autoSave: true,
+    theme: "dark",
+    exportFormat: "markdown",
+    maxIterations: 10
+  },
+  tools: {
+    enabled: [],
+    disabled: ["blog_publish", "blog_edit", "blog_draft"],
+    // Web-only tools
+    config: {}
+  },
+  trustedTools: []
+  // No tools trusted by default
+};
+function findProjectConfigDir(startDir = process.cwd()) {
+  let currentDir = startDir;
+  const { root } = path.parse(currentDir);
+  while (currentDir !== root) {
+    const gitPath = path.join(currentDir, ".git");
+    try {
+      if (existsSync(gitPath)) {
+        return currentDir;
+      }
+    } catch {
+    }
+    currentDir = path.dirname(currentDir);
+  }
+  return process.cwd();
+}
+async function loadProjectConfig(projectDir) {
+  const configPath = path.join(projectDir, ".bike4mind", "config.json");
+  try {
+    const data = await fs.readFile(configPath, "utf-8");
+    const rawConfig = JSON.parse(data);
+    const validated = ProjectConfigSchema.parse(rawConfig);
+    return validated;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return null;
+    }
+    if (error instanceof z.ZodError) {
+      console.error("Project config validation error:", error.errors);
+      return null;
+    }
+    console.error("Failed to load project config:", error);
+    return null;
+  }
+}
+async function loadProjectLocalConfig(projectDir) {
+  const configPath = path.join(projectDir, ".bike4mind", "local.json");
+  try {
+    const data = await fs.readFile(configPath, "utf-8");
+    const rawConfig = JSON.parse(data);
+    const validated = ProjectLocalConfigSchema.parse(rawConfig);
+    return validated;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return null;
+    }
+    if (error instanceof z.ZodError) {
+      console.error("Project local config validation error:", error.errors);
+      return null;
+    }
+    console.error("Failed to load project local config:", error);
+    return null;
+  }
+}
+function mergeMcpServers(...serverArrays) {
+  const serverMap = /* @__PURE__ */ new Map();
+  for (const servers of serverArrays) {
+    if (servers) {
+      for (const server of servers) {
+        serverMap.set(server.name, server);
+      }
+    }
+  }
+  return Array.from(serverMap.values());
+}
+function mergeConfigs(global, project, local) {
+  const merged = { ...global };
+  if (project) {
+    if (project.defaultModel) {
+      merged.defaultModel = project.defaultModel;
+    }
+    if (project.preferences) {
+      merged.preferences = {
+        ...merged.preferences,
+        ...project.preferences
+      };
+    }
+    if (project.tools) {
+      merged.tools = {
+        ...merged.tools,
+        enabled: [...merged.tools.enabled || [], ...project.tools.enabled || []],
+        disabled: [...merged.tools.disabled, ...project.tools.denied || []],
+        config: {
+          ...merged.tools.config,
+          ...project.tools.config
+        }
+      };
+    }
+    if (project.mcpServers) {
+      merged.mcpServers = mergeMcpServers(merged.mcpServers, project.mcpServers);
+    }
+  }
+  if (local) {
+    if (local.trustedTools) {
+      const trustedSet = /* @__PURE__ */ new Set([...merged.trustedTools || [], ...local.trustedTools]);
+      merged.trustedTools = Array.from(trustedSet);
+    }
+    if (local.toolApiKeys) {
+      merged.toolApiKeys = {
+        ...merged.toolApiKeys,
+        ...local.toolApiKeys
+      };
+    }
+    if (local.preferences) {
+      merged.preferences = {
+        ...merged.preferences,
+        ...local.preferences
+      };
+    }
+    if (local.mcpServers) {
+      merged.mcpServers = mergeMcpServers(merged.mcpServers, local.mcpServers);
+    }
+  }
+  return merged;
+}
+var ConfigStore = class {
+  constructor(configPath) {
+    this.config = null;
+    this.projectConfigDir = null;
+    this.configPath = configPath || path.join(homedir(), ".bike4mind", "config.json");
+  }
+  /**
+   * Initialize config directory
+   */
+  async init() {
+    const dir = path.dirname(this.configPath);
+    try {
+      await fs.mkdir(dir, { recursive: true });
+    } catch (error) {
+      console.error("Failed to initialize config directory:", error);
+      throw error;
+    }
+  }
+  /**
+   * Load configuration from disk with Zod validation
+   * Merges global → project → local configs
+   */
+  async load() {
+    if (this.config) {
+      return this.config;
+    }
+    try {
+      let globalConfig;
+      try {
+        try {
+          const stats = await fs.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);
+          }
+        } catch (statError) {
+        }
+        const data = await fs.readFile(this.configPath, "utf-8");
+        const rawConfig = JSON.parse(data);
+        if (rawConfig.apiConfig && "environment" in rawConfig.apiConfig) {
+          const oldApiConfig = rawConfig.apiConfig;
+          if (oldApiConfig.environment === "custom" && oldApiConfig.customUrl) {
+            rawConfig.apiConfig = { customUrl: oldApiConfig.customUrl };
+          } else {
+            rawConfig.apiConfig = {};
+          }
+        }
+        const validated = CliConfigSchema.parse(rawConfig);
+        globalConfig = {
+          ...DEFAULT_CONFIG,
+          ...validated,
+          auth: validated.auth,
+          // Explicitly preserve auth field
+          preferences: {
+            ...DEFAULT_CONFIG.preferences,
+            ...validated.preferences
+          },
+          tools: {
+            ...DEFAULT_CONFIG.tools,
+            ...validated.tools
+          },
+          toolApiKeys: {
+            ...DEFAULT_CONFIG.toolApiKeys,
+            ...validated.toolApiKeys || {}
+          },
+          trustedTools: validated.trustedTools || []
+        };
+      } catch (error) {
+        if (error.code === "ENOENT") {
+          globalConfig = { ...DEFAULT_CONFIG };
+        } else if (error instanceof z.ZodError) {
+          console.error("Global config validation error:", error.errors);
+          console.error("Using default configuration");
+          globalConfig = { ...DEFAULT_CONFIG };
+        } else {
+          throw error;
+        }
+      }
+      let projectConfig = null;
+      let projectLocalConfig = null;
+      if (process.env.B4M_NO_PROJECT_CONFIG !== "1") {
+        this.projectConfigDir = findProjectConfigDir();
+        if (this.projectConfigDir) {
+          projectConfig = await loadProjectConfig(this.projectConfigDir);
+          projectLocalConfig = await loadProjectLocalConfig(this.projectConfigDir);
+          if (projectConfig) {
+            console.log(`\u{1F4C1} Project config loaded from: ${this.projectConfigDir}/.bike4mind/`);
+          }
+        }
+      } else {
+        this.projectConfigDir = null;
+      }
+      this.config = mergeConfigs(globalConfig, projectConfig, projectLocalConfig);
+      return this.config;
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return this.reset();
+      }
+      if (error instanceof z.ZodError) {
+        console.error("Config validation error:", error.errors);
+        console.error("Resetting to default configuration");
+        return this.reset();
+      }
+      console.error("Failed to load config:", error);
+      throw error;
+    }
+  }
+  /**
+   * Save configuration to disk
+   */
+  async save(config) {
+    await this.init();
+    if (config) {
+      const existingConfig = await this.load();
+      this.config = {
+        ...existingConfig,
+        ...config,
+        auth: config.auth !== void 0 ? config.auth : existingConfig.auth,
+        preferences: {
+          ...existingConfig.preferences,
+          ...config.preferences || {}
+        },
+        tools: {
+          ...existingConfig.tools,
+          ...config.tools || {}
+        },
+        toolApiKeys: {
+          ...existingConfig.toolApiKeys,
+          ...config.toolApiKeys || {}
+        }
+      };
+    }
+    if (!this.config) {
+      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);
+    } catch (error) {
+      console.error("Failed to save config:", error);
+      throw error;
+    }
+  }
+  /**
+   * Reset configuration to defaults
+   */
+  async reset() {
+    this.config = { ...DEFAULT_CONFIG, userId: uuidv4() };
+    await this.save();
+    return this.config;
+  }
+  /**
+   * Get current configuration
+   */
+  async get() {
+    return this.load();
+  }
+  /**
+   * Update a specific configuration value
+   */
+  async update(updates) {
+    await this.save(updates);
+  }
+  /**
+   * Add MCP server configuration
+   */
+  async addMcpServer(server) {
+    const config = await this.load();
+    config.mcpServers = config.mcpServers.filter((s) => s.name !== server.name);
+    config.mcpServers.push(server);
+    await this.save(config);
+  }
+  /**
+   * Remove MCP server configuration
+   */
+  async removeMcpServer(name) {
+    const config = await this.load();
+    config.mcpServers = config.mcpServers.filter((s) => s.name !== name);
+    await this.save(config);
+  }
+  /**
+   * Enable/disable MCP server
+   */
+  async toggleMcpServer(name, enabled) {
+    const config = await this.load();
+    const server = config.mcpServers.find((s) => s.name === name);
+    if (server) {
+      server.enabled = enabled;
+      await this.save(config);
+    }
+  }
+  /**
+   * Add a tool to trusted tools list
+   */
+  async trustTool(toolName) {
+    const config = await this.load();
+    if (!config.trustedTools) {
+      config.trustedTools = [];
+    }
+    if (!config.trustedTools.includes(toolName)) {
+      config.trustedTools.push(toolName);
+      await this.save(config);
+    }
+  }
+  /**
+   * Remove a tool from trusted tools list
+   */
+  async untrustTool(toolName) {
+    const config = await this.load();
+    if (config.trustedTools) {
+      config.trustedTools = config.trustedTools.filter((t) => t !== toolName);
+      await this.save(config);
+    }
+  }
+  /**
+   * Get list of trusted tools
+   */
+  async getTrustedTools() {
+    const config = await this.load();
+    return config.trustedTools || [];
+  }
+  /**
+   * Clear all trusted tools
+   */
+  async clearTrustedTools() {
+    const config = await this.load();
+    config.trustedTools = [];
+    await this.save(config);
+  }
+  /**
+   * Get authentication tokens
+   */
+  async getAuthTokens() {
+    const config = await this.load();
+    return config.auth || null;
+  }
+  /**
+   * Set authentication tokens
+   */
+  async setAuthTokens(tokens) {
+    const config = await this.load();
+    config.auth = tokens;
+    await this.save(config);
+  }
+  /**
+   * Clear authentication tokens (logout)
+   */
+  async clearAuthTokens() {
+    const config = await this.load();
+    config.auth = void 0;
+    await this.save(config);
+  }
+  /**
+   * Check if user is authenticated
+   */
+  async isAuthenticated() {
+    const tokens = await this.getAuthTokens();
+    if (!tokens) return false;
+    const expiresAt = new Date(tokens.expiresAt);
+    return expiresAt > /* @__PURE__ */ new Date();
+  }
+  /**
+   * Get API configuration
+   */
+  async getApiConfig() {
+    const config = await this.load();
+    return config.apiConfig;
+  }
+  /**
+   * Set custom API URL for self-hosted Bike4Mind instance
+   * Pass null to reset to Bike4Mind main service
+   */
+  async setCustomApiUrl(url) {
+    const config = await this.load();
+    if (url === null) {
+      config.apiConfig = void 0;
+    } else {
+      config.apiConfig = { customUrl: url };
+    }
+    await this.save(config);
+  }
+  /**
+   * Get project config directory (if any)
+   */
+  getProjectConfigDir() {
+    return this.projectConfigDir;
+  }
+  /**
+   * Initialize project config directory
+   * Creates .bike4mind/ directory and ensures local.json is gitignored
+   * Does NOT auto-create config.json (user creates that manually)
+   */
+  async initProjectConfig() {
+    const projectDir = this.projectConfigDir || findProjectConfigDir();
+    if (!projectDir) {
+      return;
+    }
+    const configDir = path.join(projectDir, ".bike4mind");
+    await fs.mkdir(configDir, { recursive: true });
+    await this.ensureGitignore(projectDir);
+  }
+  /**
+   * Ensure .gitignore includes .bike4mind/local.json
+   */
+  async ensureGitignore(projectDir) {
+    const gitignorePath = path.join(projectDir, ".gitignore");
+    const entryToAdd = ".bike4mind/local.json";
+    try {
+      let gitignoreContent = "";
+      try {
+        gitignoreContent = await fs.readFile(gitignorePath, "utf-8");
+      } catch {
+      }
+      if (gitignoreContent.includes(entryToAdd)) {
+        return;
+      }
+      const newContent = gitignoreContent.trim() + (gitignoreContent ? "\n" : "") + `
+# Bike4Mind local config (developer-specific)
+${entryToAdd}
+`;
+      await fs.writeFile(gitignorePath, newContent, "utf-8");
+      console.log(`\u2705 Added ${entryToAdd} to .gitignore`);
+    } catch (error) {
+      console.warn(`\u26A0\uFE0F  Failed to update .gitignore:`, error);
+    }
+  }
+  /**
+   * Save project config to .bike4mind/config.json
+   */
+  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 validated = ProjectConfigSchema.parse(config);
+    await fs.writeFile(configPath, JSON.stringify(validated, null, 2), "utf-8");
+    console.log(`\u2705 Saved project config to: ${configPath}`);
+  }
+  /**
+   * Save project-local config to .bike4mind/local.json
+   */
+  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 validated = ProjectLocalConfigSchema.parse(config);
+    await fs.writeFile(configPath, JSON.stringify(validated, null, 2), "utf-8");
+    await fs.chmod(configPath, 384);
+    console.log(`\u2705 Saved project-local config to: ${configPath}`);
+  }
+  /**
+   * Load raw project config (without merging)
+   */
+  async loadRawProjectConfig() {
+    if (!this.projectConfigDir) {
+      return null;
+    }
+    return loadProjectConfig(this.projectConfigDir);
+  }
+  /**
+   * Load raw project-local config (without merging)
+   */
+  async loadRawProjectLocalConfig() {
+    if (!this.projectConfigDir) {
+      return null;
+    }
+    return loadProjectLocalConfig(this.projectConfigDir);
+  }
+};
+
+export {
+  ConfigStore
+};