@within-7/minto 0.4.1 → 0.4.3

package/dist/utils/teamConfig.js

@@ -1,624 +0,0 @@
-import { existsSync, readFileSync } from "fs";
-import {
-  getGlobalConfig,
-  saveGlobalConfig
-} from "./config.js";
-import { debug as debugLogger } from "./debugLogger.js";
-import { safeParseJSON } from "./json.js";
-import { ensureProxyBypass, hasSystemProxy } from "./envConfig.js";
-function interpolateEnvVars(value) {
-  return value.replace(/\$\{([^}]+)\}/g, (match, varName) => {
-    const envValue = process.env[varName.trim()];
-    if (envValue === void 0) {
-      debugLogger.warn("ENV_VAR_NOT_FOUND", {
-        varName,
-        original: match
-      });
-      return match;
-    }
-    return envValue;
-  });
-}
-function interpolateEnvVarsInObject(obj) {
-  if (typeof obj === "string") {
-    return interpolateEnvVars(obj);
-  }
-  if (Array.isArray(obj)) {
-    return obj.map((item) => interpolateEnvVarsInObject(item));
-  }
-  if (obj && typeof obj === "object") {
-    const result = {};
-    for (const [key, value] of Object.entries(obj)) {
-      result[key] = interpolateEnvVarsInObject(value);
-    }
-    return result;
-  }
-  return obj;
-}
-function convertTeamModelProfile(teamProfile) {
-  const now = Date.now();
-  return {
-    name: teamProfile.name,
-    provider: teamProfile.provider,
-    modelName: teamProfile.modelName,
-    baseURL: teamProfile.baseURL,
-    apiKey: interpolateEnvVars(teamProfile.apiKey),
-    maxTokens: teamProfile.maxTokens,
-    contextLength: teamProfile.contextLength,
-    reasoningEffort: teamProfile.reasoningEffort,
-    isActive: teamProfile.isActive ?? true,
-    createdAt: now,
-    lastUsed: now
-  };
-}
-function convertTeamMcpConfig(teamConfig) {
-  if (teamConfig.type === "sse") {
-    return {
-      type: "sse",
-      url: interpolateEnvVars(teamConfig.url || ""),
-      enabled: teamConfig.enabled ?? true
-    };
-  }
-  const env = teamConfig.env ? ensureProxyBypass(interpolateEnvVarsInObject(teamConfig.env)) : hasSystemProxy() ? { no_proxy: "*", NO_PROXY: "*" } : void 0;
-  return {
-    type: "stdio",
-    command: interpolateEnvVars(teamConfig.command || ""),
-    args: (teamConfig.args || []).map((arg) => interpolateEnvVars(arg)),
-    env,
-    enabled: teamConfig.enabled ?? true
-  };
-}
-async function fetchTeamConfig(url) {
-  debugLogger.state("TEAM_CONFIG_FETCH_START", { url });
-  try {
-    const response = await fetch(url, {
-      signal: AbortSignal.timeout(3e4)
-    });
-    if (!response.ok) {
-      throw new Error(
-        `Failed to fetch config: ${response.status} ${response.statusText}`
-      );
-    }
-    const configText = await response.text();
-    const config = JSON.parse(configText);
-    if (config.version !== "1.0") {
-      throw new Error(
-        `Unsupported config version: ${config.version}. Expected 1.0`
-      );
-    }
-    debugLogger.state("TEAM_CONFIG_FETCH_SUCCESS", {
-      url,
-      configName: config.name,
-      hasModels: !!config.models,
-      hasMcpServers: !!config.mcpServers
-    });
-    return config;
-  } catch (error) {
-    debugLogger.error("TEAM_CONFIG_FETCH_ERROR", {
-      url,
-      error: error instanceof Error ? error.message : String(error)
-    });
-    throw error;
-  }
-}
-function loadTeamConfigFromFile(filePath) {
-  debugLogger.state("TEAM_CONFIG_LOAD_FILE", { filePath });
-  if (!existsSync(filePath)) {
-    throw new Error(`Configuration file not found: ${filePath}`);
-  }
-  try {
-    const configText = readFileSync(filePath, "utf-8");
-    const config = safeParseJSON(configText);
-    if (!config) {
-      throw new Error("Invalid JSON in configuration file");
-    }
-    if (config.version !== "1.0") {
-      throw new Error(
-        `Unsupported config version: ${config.version}. Expected 1.0`
-      );
-    }
-    debugLogger.state("TEAM_CONFIG_LOAD_FILE_SUCCESS", {
-      filePath,
-      configName: config.name
-    });
-    return config;
-  } catch (error) {
-    debugLogger.error("TEAM_CONFIG_LOAD_FILE_ERROR", {
-      filePath,
-      error: error instanceof Error ? error.message : String(error)
-    });
-    throw error;
-  }
-}
-function applyTeamConfig(teamConfig, strategy = "merge") {
-  debugLogger.state("TEAM_CONFIG_APPLY_START", {
-    configName: teamConfig.name,
-    strategy
-  });
-  const globalConfig = getGlobalConfig();
-  let modelsAdded = 0;
-  let mcpServersAdded = 0;
-  const settingsUpdated = [];
-  if (teamConfig.models?.profiles) {
-    const existingProfiles = globalConfig.modelProfiles || [];
-    const existingModelNames = new Set(existingProfiles.map((p) => p.modelName));
-    for (const teamProfile of teamConfig.models.profiles) {
-      const runtimeProfile = convertTeamModelProfile(teamProfile);
-      if (strategy === "skip-existing" && existingModelNames.has(runtimeProfile.modelName)) {
-        debugLogger.state("TEAM_CONFIG_SKIP_MODEL", {
-          modelName: runtimeProfile.modelName,
-          reason: "already_exists"
-        });
-        continue;
-      }
-      if (strategy === "replace") {
-        const index = existingProfiles.findIndex(
-          (p) => p.modelName === runtimeProfile.modelName
-        );
-        if (index !== -1) {
-          existingProfiles.splice(index, 1);
-        }
-      }
-      existingProfiles.push(runtimeProfile);
-      modelsAdded++;
-      debugLogger.state("TEAM_CONFIG_ADD_MODEL", {
-        modelName: runtimeProfile.modelName,
-        provider: runtimeProfile.provider
-      });
-    }
-    globalConfig.modelProfiles = existingProfiles;
-  }
-  if (teamConfig.models?.pointers) {
-    globalConfig.modelPointers = {
-      ...globalConfig.modelPointers || {
-        main: "",
-        task: "",
-        reasoning: "",
-        quick: "",
-        compact: ""
-      },
-      ...teamConfig.models.pointers
-    };
-    settingsUpdated.push("modelPointers");
-  }
-  if (teamConfig.models?.defaultModel) {
-    globalConfig.defaultModelName = teamConfig.models.defaultModel;
-    settingsUpdated.push("defaultModelName");
-  }
-  if (teamConfig.mcpServers) {
-    const existingMcpServers = globalConfig.mcpServers || {};
-    const existingServerNames = new Set(Object.keys(existingMcpServers));
-    for (const [serverName, teamMcpConfig] of Object.entries(
-      teamConfig.mcpServers
-    )) {
-      if (strategy === "skip-existing" && existingServerNames.has(serverName)) {
-        debugLogger.state("TEAM_CONFIG_SKIP_MCP", {
-          serverName,
-          reason: "already_exists"
-        });
-        continue;
-      }
-      const runtimeMcpConfig = convertTeamMcpConfig(teamMcpConfig);
-      existingMcpServers[serverName] = runtimeMcpConfig;
-      mcpServersAdded++;
-      debugLogger.state("TEAM_CONFIG_ADD_MCP", {
-        serverName,
-        type: runtimeMcpConfig.type || "stdio"
-      });
-    }
-    globalConfig.mcpServers = existingMcpServers;
-  }
-  if (teamConfig.settings) {
-    const { settings } = teamConfig;
-    if (settings.theme !== void 0) {
-      globalConfig.theme = settings.theme;
-      settingsUpdated.push("theme");
-    }
-    if (settings.verbose !== void 0) {
-      globalConfig.verbose = settings.verbose;
-      settingsUpdated.push("verbose");
-    }
-    if (settings.compressionMode !== void 0) {
-      globalConfig.compressionMode = settings.compressionMode;
-      settingsUpdated.push("compressionMode");
-    }
-    if (settings.thinking !== void 0) {
-      globalConfig.thinking = settings.thinking;
-      settingsUpdated.push("thinking");
-    }
-    if (settings.proxy !== void 0) {
-      globalConfig.proxy = settings.proxy;
-      settingsUpdated.push("proxy");
-    }
-    if (settings.stream !== void 0) {
-      globalConfig.stream = settings.stream;
-      settingsUpdated.push("stream");
-    }
-    if (settings.language !== void 0) {
-      globalConfig.language = settings.language;
-      settingsUpdated.push("language");
-    }
-    if (settings.safetyMode !== void 0) {
-      globalConfig.safetyMode = settings.safetyMode;
-      settingsUpdated.push("safetyMode");
-    }
-    if (settings.skipOnboarding) {
-      globalConfig.hasCompletedOnboarding = true;
-      settingsUpdated.push("hasCompletedOnboarding");
-    }
-  }
-  saveGlobalConfig(globalConfig);
-  debugLogger.state("TEAM_CONFIG_APPLY_SUCCESS", {
-    configName: teamConfig.name,
-    modelsAdded,
-    mcpServersAdded,
-    settingsUpdated: settingsUpdated.join(", ")
-  });
-  return {
-    applied: true,
-    modelsAdded,
-    mcpServersAdded,
-    settingsUpdated
-  };
-}
-async function addMarketplaces(marketplaceUrls) {
-  let added = 0;
-  let failed = 0;
-  const errors = [];
-  const { addMarketplace } = await import("./marketplaceManager.js");
-  for (const url of marketplaceUrls) {
-    try {
-      debugLogger.state("TEAM_CONFIG_ADD_MARKETPLACE", { url });
-      await addMarketplace(url);
-      added++;
-      debugLogger.state("TEAM_CONFIG_ADD_MARKETPLACE_SUCCESS", { url });
-    } catch (error) {
-      failed++;
-      const errorMsg = error instanceof Error ? error.message : String(error);
-      errors.push(`${url}: ${errorMsg}`);
-      debugLogger.error("TEAM_CONFIG_ADD_MARKETPLACE_ERROR", {
-        url,
-        error: errorMsg
-      });
-    }
-  }
-  return { added, failed, errors };
-}
-async function installPlugins(pluginNames, targetDir) {
-  let installed = 0;
-  let failed = 0;
-  const errors = [];
-  const { installPluginFromMarketplace } = await import("./marketplaceManager.js");
-  const { join } = await import("path");
-  const { homedir } = await import("os");
-  const installDir = targetDir || join(homedir(), ".minto", "plugins");
-  for (const pluginSpec of pluginNames) {
-    const atIndex = pluginSpec.indexOf("@");
-    const pluginName = atIndex !== -1 ? pluginSpec.slice(0, atIndex) : pluginSpec;
-    const marketplaceName = atIndex !== -1 ? pluginSpec.slice(atIndex + 1) : void 0;
-    try {
-      debugLogger.state("TEAM_CONFIG_INSTALL_PLUGIN", {
-        pluginName,
-        marketplace: marketplaceName,
-        targetDir: installDir
-      });
-      await installPluginFromMarketplace(
-        pluginName,
-        marketplaceName,
-        join(installDir, pluginName)
-      );
-      installed++;
-      debugLogger.state("TEAM_CONFIG_INSTALL_PLUGIN_SUCCESS", { pluginName });
-    } catch (error) {
-      failed++;
-      const errorMsg = error instanceof Error ? error.message : String(error);
-      errors.push(`${pluginName}: ${errorMsg}`);
-      debugLogger.error("TEAM_CONFIG_INSTALL_PLUGIN_ERROR", {
-        pluginName,
-        error: errorMsg
-      });
-    }
-  }
-  return { installed, failed, errors };
-}
-async function installRemoteAgents(agentUrls, targetDir) {
-  let installed = 0;
-  let failed = 0;
-  const errors = [];
-  const { join } = await import("path");
-  const { homedir } = await import("os");
-  const { writeFileSync, mkdirSync, existsSync: existsSync2 } = await import("fs");
-  const agentsDir = targetDir || join(homedir(), ".minto", "agents");
-  if (!existsSync2(agentsDir)) {
-    mkdirSync(agentsDir, { recursive: true });
-  }
-  for (const url of agentUrls) {
-    try {
-      debugLogger.state("TEAM_CONFIG_DOWNLOAD_AGENT", { url });
-      const response = await fetch(url, {
-        signal: AbortSignal.timeout(3e4)
-      });
-      if (!response.ok) {
-        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-      }
-      const content = await response.text();
-      const filename = url.split("/").pop() || "agent.md";
-      const targetPath = join(agentsDir, filename);
-      writeFileSync(targetPath, content, "utf-8");
-      installed++;
-      debugLogger.state("TEAM_CONFIG_DOWNLOAD_AGENT_SUCCESS", {
-        url,
-        targetPath
-      });
-    } catch (error) {
-      failed++;
-      const errorMsg = error instanceof Error ? error.message : String(error);
-      errors.push(`${url}: ${errorMsg}`);
-      debugLogger.error("TEAM_CONFIG_DOWNLOAD_AGENT_ERROR", {
-        url,
-        error: errorMsg
-      });
-    }
-  }
-  return { installed, failed, errors };
-}
-async function installInlineAgents(agents, targetDir) {
-  let installed = 0;
-  let failed = 0;
-  const errors = [];
-  const { join } = await import("path");
-  const { homedir } = await import("os");
-  const { writeFileSync, mkdirSync, existsSync: existsSync2 } = await import("fs");
-  const agentsDir = targetDir || join(homedir(), ".minto", "agents");
-  if (!existsSync2(agentsDir)) {
-    mkdirSync(agentsDir, { recursive: true });
-  }
-  for (const agent of agents) {
-    try {
-      debugLogger.state("TEAM_CONFIG_INSTALL_INLINE_AGENT", {
-        name: agent.name
-      });
-      const tools = agent.tools === "*" ? "*" : JSON.stringify(agent.tools);
-      const content = `---
-name: ${agent.name}
-description: "${agent.description.replace(/"/g, '\\"')}"
-tools: ${tools}${agent.model ? `
-model_name: ${agent.model}` : ""}${agent.color ? `
-color: "${agent.color}"` : ""}
----
-
-${agent.systemPrompt}
-`;
-      const filename = `${agent.name}.md`;
-      const targetPath = join(agentsDir, filename);
-      writeFileSync(targetPath, content, "utf-8");
-      installed++;
-      debugLogger.state("TEAM_CONFIG_INSTALL_INLINE_AGENT_SUCCESS", {
-        name: agent.name,
-        targetPath
-      });
-    } catch (error) {
-      failed++;
-      const errorMsg = error instanceof Error ? error.message : String(error);
-      errors.push(`${agent.name}: ${errorMsg}`);
-      debugLogger.error("TEAM_CONFIG_INSTALL_INLINE_AGENT_ERROR", {
-        name: agent.name,
-        error: errorMsg
-      });
-    }
-  }
-  return { installed, failed, errors };
-}
-async function installTeamHooks(hooks, targetPath) {
-  const { join, dirname } = await import("path");
-  const { homedir } = await import("os");
-  const { writeFileSync, mkdirSync, existsSync: existsSync2, readFileSync: readFileSync2 } = await import("fs");
-  try {
-    debugLogger.state("TEAM_CONFIG_INSTALL_HOOKS", {});
-    const hooksPath = targetPath || join(homedir(), ".minto", "hooks.json");
-    const hooksDir = dirname(hooksPath);
-    if (!existsSync2(hooksDir)) {
-      mkdirSync(hooksDir, { recursive: true });
-    }
-    const hooksConfig = {
-      description: "Team-configured hooks",
-      hooks: {}
-    };
-    const hooksObj = hooksConfig.hooks;
-    if (hooks.sessionStart) {
-      hooksObj.SessionStart = [{ matcher: "*", hooks: hooks.sessionStart }];
-    }
-    if (hooks.sessionEnd) {
-      hooksObj.SessionEnd = [{ matcher: "*", hooks: hooks.sessionEnd }];
-    }
-    if (hooks.userPromptSubmit) {
-      hooksObj.UserPromptSubmit = [
-        { matcher: "*", hooks: hooks.userPromptSubmit }
-      ];
-    }
-    if (hooks.preToolUse) {
-      hooksObj.PreToolUse = hooks.preToolUse;
-    }
-    if (hooks.postToolUse) {
-      hooksObj.PostToolUse = hooks.postToolUse;
-    }
-    if (existsSync2(hooksPath)) {
-      try {
-        const existingContent = readFileSync2(hooksPath, "utf-8");
-        const existingHooks = JSON.parse(existingContent);
-        for (const [event, matchers] of Object.entries(hooksObj)) {
-          if (existingHooks.hooks?.[event]) {
-            existingHooks.hooks[event] = [
-              ...existingHooks.hooks[event],
-              ...matchers
-            ];
-          } else {
-            existingHooks.hooks = existingHooks.hooks || {};
-            existingHooks.hooks[event] = matchers;
-          }
-        }
-        hooksConfig.hooks = existingHooks.hooks;
-      } catch {
-      }
-    }
-    writeFileSync(hooksPath, JSON.stringify(hooksConfig, null, 2), "utf-8");
-    debugLogger.state("TEAM_CONFIG_INSTALL_HOOKS_SUCCESS", { hooksPath });
-    return { installed: true };
-  } catch (error) {
-    const errorMsg = error instanceof Error ? error.message : String(error);
-    debugLogger.error("TEAM_CONFIG_INSTALL_HOOKS_ERROR", { error: errorMsg });
-    return { installed: false, error: errorMsg };
-  }
-}
-async function installInlineSkills(skills, targetDir) {
-  let installed = 0;
-  let failed = 0;
-  const errors = [];
-  const { join } = await import("path");
-  const { homedir } = await import("os");
-  const { writeFileSync, mkdirSync, existsSync: existsSync2 } = await import("fs");
-  const skillsDir = targetDir || join(homedir(), ".minto", "skills");
-  if (!existsSync2(skillsDir)) {
-    mkdirSync(skillsDir, { recursive: true });
-  }
-  for (const skill of skills) {
-    try {
-      debugLogger.state("TEAM_CONFIG_INSTALL_SKILL", { name: skill.name });
-      const frontmatterLines = [
-        `name: ${skill.name}`,
-        `description: "${skill.description.replace(/"/g, '\\"')}"`
-      ];
-      if (skill.argumentHint) {
-        frontmatterLines.push(`argument-hint: "${skill.argumentHint}"`);
-      }
-      if (skill.disableModelInvocation !== void 0) {
-        frontmatterLines.push(
-          `disable-model-invocation: ${skill.disableModelInvocation}`
-        );
-      }
-      if (skill.userInvocable !== void 0) {
-        frontmatterLines.push(`user-invocable: ${skill.userInvocable}`);
-      }
-      if (skill.allowedTools && skill.allowedTools.length > 0) {
-        frontmatterLines.push(
-          `allowed-tools: ${JSON.stringify(skill.allowedTools)}`
-        );
-      }
-      if (skill.model) {
-        frontmatterLines.push(`model: ${skill.model}`);
-      }
-      if (skill.context) {
-        frontmatterLines.push(`context: "${skill.context}"`);
-      }
-      if (skill.agent) {
-        frontmatterLines.push(`agent: "${skill.agent}"`);
-      }
-      const content = `---
-${frontmatterLines.join("\n")}
----
-
-${skill.content}
-`;
-      const filename = `${skill.name}.md`;
-      const targetPath = join(skillsDir, filename);
-      writeFileSync(targetPath, content, "utf-8");
-      installed++;
-      debugLogger.state("TEAM_CONFIG_INSTALL_SKILL_SUCCESS", {
-        name: skill.name,
-        targetPath
-      });
-    } catch (error) {
-      failed++;
-      const errorMsg = error instanceof Error ? error.message : String(error);
-      errors.push(`${skill.name}: ${errorMsg}`);
-      debugLogger.error("TEAM_CONFIG_INSTALL_SKILL_ERROR", {
-        name: skill.name,
-        error: errorMsg
-      });
-    }
-  }
-  return { installed, failed, errors };
-}
-async function installInlineCommands(commands, targetDir) {
-  let installed = 0;
-  let failed = 0;
-  const errors = [];
-  const { join } = await import("path");
-  const { homedir } = await import("os");
-  const { writeFileSync, mkdirSync, existsSync: existsSync2 } = await import("fs");
-  const commandsDir = targetDir || join(homedir(), ".minto", "commands");
-  if (!existsSync2(commandsDir)) {
-    mkdirSync(commandsDir, { recursive: true });
-  }
-  for (const cmd of commands) {
-    try {
-      debugLogger.state("TEAM_CONFIG_INSTALL_COMMAND", { name: cmd.name });
-      const frontmatterLines = [`name: ${cmd.name}`];
-      if (cmd.description) {
-        frontmatterLines.push(
-          `description: "${cmd.description.replace(/"/g, '\\"')}"`
-        );
-      }
-      if (cmd.aliases && cmd.aliases.length > 0) {
-        frontmatterLines.push(`aliases: ${JSON.stringify(cmd.aliases)}`);
-      }
-      if (cmd.enabled !== void 0) {
-        frontmatterLines.push(`enabled: ${cmd.enabled}`);
-      }
-      if (cmd.hidden !== void 0) {
-        frontmatterLines.push(`hidden: ${cmd.hidden}`);
-      }
-      if (cmd.progressMessage) {
-        frontmatterLines.push(`progressMessage: "${cmd.progressMessage}"`);
-      }
-      if (cmd.argNames && cmd.argNames.length > 0) {
-        frontmatterLines.push(`argNames: ${JSON.stringify(cmd.argNames)}`);
-      }
-      if (cmd.allowedTools && cmd.allowedTools.length > 0) {
-        frontmatterLines.push(
-          `allowed-tools: ${JSON.stringify(cmd.allowedTools)}`
-        );
-      }
-      const content = `---
-${frontmatterLines.join("\n")}
----
-
-${cmd.content}
-`;
-      const filename = `${cmd.name}.md`;
-      const targetPath = join(commandsDir, filename);
-      writeFileSync(targetPath, content, "utf-8");
-      installed++;
-      debugLogger.state("TEAM_CONFIG_INSTALL_COMMAND_SUCCESS", {
-        name: cmd.name,
-        targetPath
-      });
-    } catch (error) {
-      failed++;
-      const errorMsg = error instanceof Error ? error.message : String(error);
-      errors.push(`${cmd.name}: ${errorMsg}`);
-      debugLogger.error("TEAM_CONFIG_INSTALL_COMMAND_ERROR", {
-        name: cmd.name,
-        error: errorMsg
-      });
-    }
-  }
-  return { installed, failed, errors };
-}
-export {
-  addMarketplaces,
-  applyTeamConfig,
-  convertTeamMcpConfig,
-  convertTeamModelProfile,
-  fetchTeamConfig,
-  installInlineAgents,
-  installInlineCommands,
-  installInlineSkills,
-  installPlugins,
-  installRemoteAgents,
-  installTeamHooks,
-  interpolateEnvVars,
-  interpolateEnvVarsInObject,
-  loadTeamConfigFromFile
-};
-//# sourceMappingURL=teamConfig.js.map