autohand-cli 0.8.3 → 0.9.1

package/dist/chunk-IEPLQ47J.js

@@ -0,0 +1,719 @@
+import {
+  loadLocalProjectSettings
+} from "./chunk-5A7ZL64N.js";
+import {
+  isAwsBedrockProviderEnabled
+} from "./chunk-LANGD5CO.js";
+import {
+  autoInitTheme,
+  configureThemeSources,
+  themeExists
+} from "./chunk-NBGOIFKP.js";
+import {
+  AUTOHAND_FILES
+} from "./chunk-SHRLFX6F.js";
+
+// src/config.ts
+import fs from "fs-extra";
+import path from "path";
+import YAML from "yaml";
+var DEFAULT_CONFIG_PATH = AUTOHAND_FILES.configJson;
+var TOML_CONFIG_PATH = AUTOHAND_FILES.configToml;
+var YAML_CONFIG_PATH = AUTOHAND_FILES.configYaml;
+var YML_CONFIG_PATH = AUTOHAND_FILES.configYml;
+var DEFAULT_BASE_URL = "https://openrouter.ai/api/v1";
+var DEFAULT_OLLAMA_URL = "http://localhost:11434";
+var DEFAULT_LLAMACPP_URL = "http://localhost:8080";
+var DEFAULT_OPENAI_URL = "https://api.openai.com/v1";
+var DEFAULT_MLX_URL = "http://localhost:8080";
+var DEFAULT_LLMGATEWAY_URL = "https://api.llmgateway.io/v1";
+var DEFAULT_ZAI_URL = "https://api.z.ai/api/paas/v4";
+var DEFAULT_DEEPSEEK_URL = "https://api.deepseek.com";
+var DEFAULT_BEDROCK_REGION = "us-east-1";
+function normalizeProviderName(provider) {
+  if (provider === void 0) {
+    return void 0;
+  }
+  if (provider === "vertex") {
+    return "vertexai";
+  }
+  const validProviders = [
+    "openrouter",
+    "ollama",
+    "llamacpp",
+    "openai",
+    "mlx",
+    "llmgateway",
+    "azure",
+    "zai",
+    "vertexai",
+    "xai",
+    "cerebras",
+    "nvidia",
+    "deepseek",
+    "bedrock"
+  ];
+  if (typeof provider === "string" && validProviders.includes(provider)) {
+    return provider;
+  }
+  return void 0;
+}
+function getDefaultConfigPath() {
+  return DEFAULT_CONFIG_PATH;
+}
+async function detectConfigPath(customPath) {
+  if (customPath) {
+    return path.resolve(customPath);
+  }
+  const envPath = process.env.AUTOHAND_CONFIG;
+  if (envPath) {
+    return path.resolve(envPath);
+  }
+  if (await fs.pathExists(TOML_CONFIG_PATH)) {
+    return TOML_CONFIG_PATH;
+  }
+  if (await fs.pathExists(YAML_CONFIG_PATH)) {
+    return YAML_CONFIG_PATH;
+  }
+  if (await fs.pathExists(YML_CONFIG_PATH)) {
+    return YML_CONFIG_PATH;
+  }
+  return DEFAULT_CONFIG_PATH;
+}
+async function checkConfigFilesExist(dir) {
+  const files = [];
+  for (const filename of ["config.json", "config.toml", "config.yaml", "config.yml"]) {
+    const candidate = path.join(dir, filename);
+    if (await fs.pathExists(candidate)) {
+      files.push(filename);
+    }
+  }
+  return files.sort();
+}
+function isYamlFile(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  return ext === ".yaml" || ext === ".yml";
+}
+function isTomlFile(filePath) {
+  return path.extname(filePath).toLowerCase() === ".toml";
+}
+function stripTomlComment(line) {
+  let inSingle = false;
+  let inDouble = false;
+  let escaped = false;
+  for (let i = 0; i < line.length; i += 1) {
+    const char = line[i];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (inDouble && char === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (!inDouble && char === "'") {
+      inSingle = !inSingle;
+      continue;
+    }
+    if (!inSingle && char === '"') {
+      inDouble = !inDouble;
+      continue;
+    }
+    if (!inSingle && !inDouble && char === "#") {
+      return line.slice(0, i).trim();
+    }
+  }
+  return line.trim();
+}
+function splitTomlPath(input) {
+  return input.split(".").map((part) => part.trim().replace(/^"(.*)"$/, "$1")).filter(Boolean);
+}
+function parseTomlValue(raw) {
+  const value = raw.trim();
+  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+    if (value.startsWith('"')) {
+      try {
+        return JSON.parse(value);
+      } catch {
+        return value.slice(1, -1);
+      }
+    }
+    return value.slice(1, -1);
+  }
+  if (value === "true") return true;
+  if (value === "false") return false;
+  if (/^-?\d+(?:\.\d+)?$/.test(value)) return Number(value);
+  if (value.startsWith("[") && value.endsWith("]")) {
+    const inner = value.slice(1, -1).trim();
+    if (!inner) return [];
+    return inner.split(",").map((entry) => parseTomlValue(entry.trim())).filter((entry) => typeof entry !== "object");
+  }
+  return value;
+}
+function getOrCreateTomlSection(root, pathParts) {
+  let current = root;
+  for (const part of pathParts) {
+    const existing = current[part];
+    if (Array.isArray(existing)) {
+      const last = existing[existing.length - 1];
+      if (last && typeof last === "object" && !Array.isArray(last)) {
+        current = last;
+        continue;
+      }
+    }
+    if (!existing || typeof existing !== "object" || Array.isArray(existing)) {
+      current[part] = {};
+    }
+    current = current[part];
+  }
+  return current;
+}
+function getOrCreateTomlArraySection(root, pathParts) {
+  const parent = getOrCreateTomlSection(root, pathParts.slice(0, -1));
+  const key = pathParts[pathParts.length - 1];
+  const existing = parent[key];
+  if (!Array.isArray(existing)) {
+    parent[key] = [];
+  }
+  const section = {};
+  parent[key].push(section);
+  return section;
+}
+function parseTomlConfig(content) {
+  const root = {};
+  let current = root;
+  let hasData = false;
+  for (const rawLine of content.split(/\r?\n/)) {
+    const line = stripTomlComment(rawLine);
+    if (!line) continue;
+    const arraySection = line.match(/^\[\[([^\]]+)]]$/);
+    if (arraySection) {
+      current = getOrCreateTomlArraySection(root, splitTomlPath(arraySection[1]));
+      hasData = true;
+      continue;
+    }
+    const section = line.match(/^\[([^\]]+)]$/);
+    if (section) {
+      current = getOrCreateTomlSection(root, splitTomlPath(section[1]));
+      hasData = true;
+      continue;
+    }
+    const kv = line.match(/^([A-Za-z0-9_-]+)\s*=\s*(.+)$/);
+    if (!kv) {
+      throw new Error(`Invalid TOML line: ${rawLine.trim()}`);
+    }
+    current[kv[1]] = parseTomlValue(kv[2]);
+    hasData = true;
+  }
+  if (!hasData) {
+    throw new Error(
+      `Config file is empty or contains no valid data. You can fix this by editing the file, or delete it and run 'autohand --setup' to recreate.`
+    );
+  }
+  return root;
+}
+function isPlainObject(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function formatTomlKey(key) {
+  return /^[A-Za-z0-9_-]+$/.test(key) ? key : JSON.stringify(key);
+}
+function formatTomlValue(value) {
+  if (typeof value === "string") return JSON.stringify(value);
+  if (typeof value === "number" && Number.isFinite(value)) return String(value);
+  if (typeof value === "boolean") return value ? "true" : "false";
+  if (Array.isArray(value) && value.every((entry) => !isPlainObject(entry) && !Array.isArray(entry))) {
+    return `[${value.map((entry) => formatTomlValue(entry)).filter((entry) => entry !== null).join(", ")}]`;
+  }
+  return null;
+}
+function stringifyTomlObject(data) {
+  const lines = [];
+  const writeSection = (sectionPath, section) => {
+    const scalarEntries = Object.entries(section).filter(([, value]) => formatTomlValue(value) !== null);
+    if (sectionPath.length > 0) {
+      if (lines.length > 0) lines.push("");
+      lines.push(`[${sectionPath.map(formatTomlKey).join(".")}]`);
+    }
+    for (const [key, value] of scalarEntries) {
+      const formatted = formatTomlValue(value);
+      if (formatted !== null) {
+        lines.push(`${formatTomlKey(key)} = ${formatted}`);
+      }
+    }
+    for (const [key, value] of Object.entries(section)) {
+      if (isPlainObject(value)) {
+        writeSection([...sectionPath, key], value);
+      } else if (Array.isArray(value) && value.every(isPlainObject)) {
+        for (const item of value) {
+          if (lines.length > 0) lines.push("");
+          const childPath = [...sectionPath, key];
+          lines.push(`[[${childPath.map(formatTomlKey).join(".")}]]`);
+          for (const [childKey, childValue] of Object.entries(item)) {
+            const formatted = formatTomlValue(childValue);
+            if (formatted !== null) {
+              lines.push(`${formatTomlKey(childKey)} = ${formatted}`);
+            }
+          }
+          for (const [childKey, childValue] of Object.entries(item)) {
+            if (isPlainObject(childValue)) {
+              writeSection([...childPath, childKey], childValue);
+            }
+          }
+        }
+      }
+    }
+  };
+  writeSection([], data);
+  return `${lines.join("\n")}
+`;
+}
+async function parseConfigFile(configPath) {
+  const rawContent = await fs.readFile(configPath, "utf8");
+  const content = rawContent.charCodeAt(0) === 65279 ? rawContent.slice(1) : rawContent;
+  if (isYamlFile(configPath)) {
+    const parsed = YAML.parse(content);
+    if (parsed === null || parsed === void 0) {
+      throw new Error(
+        `Config file is empty or contains no valid data. You can fix this by editing ${configPath}, or delete it and run 'autohand --setup' to recreate.`
+      );
+    }
+    return parsed;
+  }
+  if (isTomlFile(configPath)) {
+    return parseTomlConfig(content);
+  }
+  return JSON.parse(content);
+}
+async function loadConfig(customPath, workspaceRoot) {
+  const configPath = await detectConfigPath(customPath);
+  const configDir = path.dirname(configPath);
+  const configFiles = await checkConfigFilesExist(configDir);
+  if (configFiles.length > 1) {
+    throw new Error(
+      `Multiple config files found in ${configDir} (${configFiles.join(", ")}). Only one config file is allowed. Please review and remove the duplicate, or set the AUTOHAND_CONFIG environment variable to specify which one to use.`
+    );
+  }
+  await fs.ensureDir(path.dirname(configPath));
+  let isNewConfig = false;
+  if (!await fs.pathExists(configPath)) {
+    const defaultConfig = {
+      provider: "openrouter",
+      openrouter: {
+        apiKey: "",
+        baseUrl: "https://openrouter.ai/api/v1",
+        model: "openrouter/auto"
+      },
+      workspace: {
+        defaultRoot: process.cwd(),
+        allowDangerousOps: false
+      },
+      ui: {
+        theme: "dark",
+        autoConfirm: false,
+        silentToolOutput: false,
+        completionReportEnabled: true,
+        activityVerbsEnabled: true,
+        promptSuggestions: true
+      },
+      telemetry: {
+        enabled: false
+      },
+      autoReport: {
+        enabled: true
+      },
+      agent: {
+        toolSelectionCache: true
+      }
+    };
+    await fs.writeJson(configPath, defaultConfig, { spaces: 2 });
+    isNewConfig = true;
+  }
+  let parsed;
+  try {
+    parsed = await parseConfigFile(configPath);
+  } catch (error) {
+    const originalMessage = error.message;
+    const alreadyHasSuggestion = originalMessage.includes("autohand --setup");
+    const suggestion = alreadyHasSuggestion ? "" : ` You can fix this by editing ${configPath}, or delete it and run 'autohand --setup' to recreate.`;
+    throw new Error(
+      `Failed to parse config at ${configPath}: ${originalMessage}${suggestion}`
+    );
+  }
+  const normalized = normalizeConfig(parsed);
+  let workspaceSettings = null;
+  if (workspaceRoot) {
+    workspaceSettings = await loadLocalProjectSettings(workspaceRoot);
+  }
+  const withWorkspace = mergeWorkspaceSettings(normalized, workspaceSettings);
+  const withEnv = mergeEnvVariables(withWorkspace);
+  configureThemeSources({ inlineThemes: withEnv.ui?.customThemes });
+  validateConfig(withEnv, configPath);
+  const themeName = withEnv.ui?.theme || "dark";
+  autoInitTheme(themeName);
+  return { ...withEnv, configPath, isNewConfig };
+}
+function mergeWorkspaceSettings(globalConfig, workspaceSettings) {
+  if (!workspaceSettings) {
+    return globalConfig;
+  }
+  const merged = { ...globalConfig };
+  if (workspaceSettings.provider !== void 0) {
+    merged.provider = workspaceSettings.provider;
+  }
+  if (workspaceSettings.model !== void 0) {
+    const provider = workspaceSettings.provider || merged.provider;
+    if (provider && merged[provider]) {
+      merged[provider].model = workspaceSettings.model;
+    }
+  }
+  if (workspaceSettings.agent) {
+    merged.agent = {
+      ...merged.agent,
+      ...workspaceSettings.agent
+    };
+  }
+  if (workspaceSettings.network) {
+    merged.network = {
+      ...merged.network,
+      ...workspaceSettings.network
+    };
+  }
+  if (workspaceSettings.telemetry) {
+    merged.telemetry = {
+      ...merged.telemetry,
+      ...workspaceSettings.telemetry
+    };
+  }
+  if (workspaceSettings.permissions) {
+    merged.permissions = {
+      ...merged.permissions,
+      ...workspaceSettings.permissions
+    };
+  }
+  return merged;
+}
+function mergeEnvVariables(config) {
+  config = {
+    ...config,
+    api: {
+      baseUrl: process.env.AUTOHAND_API_URL || config.api?.baseUrl || "https://api.autohand.ai",
+      companySecret: process.env.AUTOHAND_SECRET || config.api?.companySecret || ""
+    }
+  };
+  if (process.env.AZURE_OPENAI_KEY || process.env.AZURE_OPENAI_ENDPOINT || process.env.AZURE_OPENAI_DEPLOYMENT) {
+    const azureEnv = {
+      apiKey: process.env.AZURE_OPENAI_KEY,
+      baseUrl: process.env.AZURE_OPENAI_ENDPOINT,
+      deploymentName: process.env.AZURE_OPENAI_DEPLOYMENT,
+      apiVersion: process.env.AZURE_OPENAI_API_VERSION,
+      tenantId: process.env.AZURE_TENANT_ID,
+      clientId: process.env.AZURE_CLIENT_ID,
+      clientSecret: process.env.AZURE_CLIENT_SECRET
+    };
+    const existing = config.azure ?? {
+      model: azureEnv.deploymentName ?? "gpt-4o"
+    };
+    config = {
+      ...config,
+      azure: {
+        ...existing,
+        ...azureEnv.apiKey && { apiKey: azureEnv.apiKey },
+        ...azureEnv.baseUrl && { baseUrl: azureEnv.baseUrl },
+        ...azureEnv.deploymentName && {
+          deploymentName: azureEnv.deploymentName
+        },
+        ...azureEnv.apiVersion && { apiVersion: azureEnv.apiVersion },
+        ...azureEnv.tenantId && { tenantId: azureEnv.tenantId },
+        ...azureEnv.clientId && { clientId: azureEnv.clientId },
+        ...azureEnv.clientSecret && { clientSecret: azureEnv.clientSecret }
+      }
+    };
+  }
+  const envRegion = process.env.AWS_REGION || process.env.AWS_DEFAULT_REGION;
+  if (envRegion && config.bedrock) {
+    config = {
+      ...config,
+      bedrock: {
+        ...config.bedrock,
+        region: config.bedrock.region || envRegion
+      }
+    };
+  }
+  return config;
+}
+function normalizeConfig(config) {
+  if (config === null || config === void 0 || typeof config !== "object") {
+    throw new Error(
+      `Config file produced an invalid value (got ${config === null ? "null" : typeof config}). Delete the config file and run 'autohand --setup' to recreate it.`
+    );
+  }
+  if (isModernConfig(config)) {
+    const provider = normalizeProviderName(config.provider) ?? "openrouter";
+    return { ...config, provider };
+  }
+  if (isLegacyConfig(config)) {
+    return {
+      provider: "openrouter",
+      openrouter: {
+        apiKey: config.api_key ?? "replace-me",
+        baseUrl: config.base_url ?? DEFAULT_BASE_URL,
+        model: "anthropic/claude-4-sonnet"
+      },
+      workspace: {
+        defaultRoot: process.cwd(),
+        allowDangerousOps: false
+      },
+      ui: {
+        autoConfirm: config.dry_run ?? false,
+        theme: "dark",
+        silentToolOutput: false,
+        completionReportEnabled: true,
+        activityVerbsEnabled: true,
+        promptSuggestions: true
+      }
+    };
+  }
+  return config;
+}
+function isModernConfig(config) {
+  return typeof config.openrouter === "object" || typeof config.ollama === "object" || typeof config.llamacpp === "object" || typeof config.openai === "object" || typeof config.mlx === "object" || typeof config.azure === "object" || typeof config.zai === "object" || typeof config.vertexai === "object" || typeof config.xai === "object" || typeof config.cerebras === "object" || typeof config.nvidia === "object" || typeof config.deepseek === "object" || typeof config.bedrock === "object";
+}
+function isLegacyConfig(config) {
+  return typeof config.api_key === "string";
+}
+function validateConfig(config, configPath) {
+  if (config.workspace) {
+    if (config.workspace.defaultRoot && typeof config.workspace.defaultRoot !== "string") {
+      throw new Error(
+        `workspace.defaultRoot must be a string in ${configPath}`
+      );
+    }
+    if (config.workspace.allowDangerousOps !== void 0 && typeof config.workspace.allowDangerousOps !== "boolean") {
+      throw new Error(
+        `workspace.allowDangerousOps must be boolean in ${configPath}`
+      );
+    }
+  }
+  if (config.ui) {
+    if (config.ui.theme && typeof config.ui.theme !== "string") {
+      throw new Error(`ui.theme must be a string in ${configPath}`);
+    }
+    if (config.ui.theme && typeof config.ui.theme === "string" && !themeExists(config.ui.theme)) {
+      console.warn(
+        `Theme '${config.ui.theme}' not found \u2014 falling back to default.`
+      );
+    }
+    if (config.ui.autoConfirm !== void 0 && typeof config.ui.autoConfirm !== "boolean") {
+      throw new Error(`ui.autoConfirm must be boolean in ${configPath}`);
+    }
+    if (config.ui.promptSuggestions !== void 0 && typeof config.ui.promptSuggestions !== "boolean") {
+      throw new Error(`ui.promptSuggestions must be boolean in ${configPath}`);
+    }
+    if (config.ui.completionReportEnabled !== void 0 && typeof config.ui.completionReportEnabled !== "boolean") {
+      throw new Error(`ui.completionReportEnabled must be boolean in ${configPath}`);
+    }
+    if (config.ui.activityVerbsEnabled !== void 0 && typeof config.ui.activityVerbsEnabled !== "boolean") {
+      throw new Error(`ui.activityVerbsEnabled must be boolean in ${configPath}`);
+    }
+  }
+  if (config.agent) {
+    if (config.agent.toolSelectionCache !== void 0 && typeof config.agent.toolSelectionCache !== "boolean") {
+      throw new Error(`agent.toolSelectionCache must be boolean in ${configPath}`);
+    }
+  }
+  if (config.mcp) {
+    if (config.mcp.enabled !== void 0 && typeof config.mcp.enabled !== "boolean") {
+      throw new Error(`mcp.enabled must be boolean in ${configPath}`);
+    }
+    if (config.mcp.servers !== void 0) {
+      if (!Array.isArray(config.mcp.servers)) {
+        throw new Error(`mcp.servers must be an array in ${configPath}`);
+      }
+      for (const server of config.mcp.servers) {
+        if (!server.name || typeof server.name !== "string") {
+          throw new Error(
+            `mcp.servers[].name must be a non-empty string in ${configPath}`
+          );
+        }
+        if (!["stdio", "sse", "http"].includes(server.transport)) {
+          throw new Error(
+            `mcp.servers[].transport must be 'stdio', 'sse', or 'http' in ${configPath}`
+          );
+        }
+        if (server.transport === "stdio" && (!server.command || typeof server.command !== "string")) {
+          throw new Error(
+            `mcp.servers[].command is required for stdio transport in ${configPath}`
+          );
+        }
+        if ((server.transport === "sse" || server.transport === "http") && (!server.url || typeof server.url !== "string")) {
+          throw new Error(
+            `mcp.servers[].url is required for ${server.transport} transport in ${configPath}`
+          );
+        }
+      }
+    }
+  }
+  if (config.externalAgents) {
+    if (config.externalAgents.enabled !== void 0 && typeof config.externalAgents.enabled !== "boolean") {
+      throw new Error(
+        `externalAgents.enabled must be boolean in ${configPath}`
+      );
+    }
+    if (config.externalAgents.paths !== void 0) {
+      if (!Array.isArray(config.externalAgents.paths)) {
+        throw new Error(
+          `externalAgents.paths must be an array in ${configPath}`
+        );
+      }
+      for (const p of config.externalAgents.paths) {
+        if (typeof p !== "string") {
+          throw new Error(
+            `externalAgents.paths must contain only strings in ${configPath}`
+          );
+        }
+      }
+    }
+  }
+}
+function resolveWorkspaceRoot(config, requestedPath) {
+  const candidate = requestedPath ?? process.cwd() ?? config.workspace?.defaultRoot;
+  return path.resolve(candidate);
+}
+function getProviderConfig(config, provider) {
+  const chosen = provider ?? config.provider ?? "openrouter";
+  if (chosen === "bedrock" && !isAwsBedrockProviderEnabled(config)) {
+    return null;
+  }
+  const configByProvider = {
+    openrouter: config.openrouter,
+    ollama: config.ollama,
+    llamacpp: config.llamacpp,
+    openai: config.openai,
+    mlx: config.mlx,
+    llmgateway: config.llmgateway,
+    azure: config.azure,
+    zai: config.zai,
+    vertexai: config.vertexai,
+    xai: config.xai,
+    cerebras: config.cerebras,
+    nvidia: config.nvidia,
+    deepseek: config.deepseek,
+    bedrock: config.bedrock
+  };
+  const entry = configByProvider[chosen];
+  if (!entry) {
+    return null;
+  }
+  if (chosen === "openai") {
+    const openAIEntry = entry;
+    if (!openAIEntry.model) {
+      return null;
+    }
+    if (openAIEntry.authMode === "chatgpt") {
+      if (!openAIEntry.chatgptAuth?.accessToken || !openAIEntry.chatgptAuth?.accountId) {
+        return null;
+      }
+    } else {
+      if (!openAIEntry.apiKey || openAIEntry.apiKey === "replace-me") {
+        return null;
+      }
+    }
+  } else if (chosen === "openrouter" || chosen === "llmgateway" || chosen === "zai" || chosen === "nvidia" || chosen === "deepseek") {
+    const { apiKey, model } = entry;
+    if (!apiKey || apiKey === "replace-me" || !model) {
+      return null;
+    }
+  } else if (chosen === "vertexai") {
+    const { authToken, projectId, model } = entry;
+    if (!authToken || !projectId || !model) {
+      return null;
+    }
+  } else if (chosen === "bedrock") {
+    return normalizeBedrockProviderConfig(entry);
+  } else {
+    if (chosen === "llamacpp") {
+      return {
+        ...entry,
+        model: entry.model ?? "local",
+        baseUrl: entry.baseUrl ?? defaultBaseUrlFor(chosen, entry.port)
+      };
+    }
+    if (!entry.model) {
+      return null;
+    }
+  }
+  return {
+    ...entry,
+    baseUrl: entry.baseUrl ?? defaultBaseUrlFor(chosen, entry.port)
+  };
+}
+function defaultBaseUrlFor(provider, port) {
+  if (provider === "openrouter") return DEFAULT_BASE_URL;
+  if (provider === "llmgateway") return DEFAULT_LLMGATEWAY_URL;
+  if (provider === "zai") return DEFAULT_ZAI_URL;
+  if (provider === "deepseek") return DEFAULT_DEEPSEEK_URL;
+  const p = port ? port.toString() : void 0;
+  switch (provider) {
+    case "ollama":
+      return p ? `http://localhost:${p}` : DEFAULT_OLLAMA_URL;
+    case "llamacpp":
+      return p ? `http://localhost:${p}` : DEFAULT_LLAMACPP_URL;
+    case "openai":
+      return DEFAULT_OPENAI_URL;
+    case "mlx":
+      return p ? `http://localhost:${p}` : DEFAULT_MLX_URL;
+    case "nvidia":
+      return "https://integrate.api.nvidia.com/v1";
+    case "bedrock":
+      return `https://bedrock-runtime.${DEFAULT_BEDROCK_REGION}.amazonaws.com`;
+    default:
+      return void 0;
+  }
+}
+function normalizeBedrockProviderConfig(entry) {
+  const model = entry.model?.trim();
+  const region = entry.region?.trim() || process.env.AWS_REGION || process.env.AWS_DEFAULT_REGION || DEFAULT_BEDROCK_REGION;
+  const apiMode = entry.apiMode ?? "converse";
+  const authMode = entry.authMode ?? (apiMode === "converse" ? "aws-credentials" : "bedrock-api-key");
+  const endpoint = entry.endpoint?.replace(/\/+$/, "") ?? (apiMode === "converse" ? `https://bedrock-runtime.${region}.amazonaws.com` : `https://bedrock-runtime.${region}.amazonaws.com/openai/v1`);
+  if (!model || !region) {
+    return null;
+  }
+  if (authMode === "bedrock-api-key" && (!entry.apiKey || entry.apiKey === "replace-me")) {
+    return null;
+  }
+  return {
+    ...entry,
+    model,
+    region,
+    apiMode,
+    authMode,
+    endpoint
+  };
+}
+async function saveConfig(config) {
+  const { configPath, ...data } = config;
+  delete data.isNewConfig;
+  if (isYamlFile(configPath)) {
+    const yamlContent = YAML.stringify(data, { indent: 2 });
+    await fs.writeFile(configPath, yamlContent, "utf8");
+  } else if (isTomlFile(configPath)) {
+    await fs.writeFile(configPath, stringifyTomlObject(data), "utf8");
+  } else {
+    await fs.writeJson(configPath, data, { spaces: 2 });
+  }
+}
+
+export {
+  getDefaultConfigPath,
+  loadConfig,
+  resolveWorkspaceRoot,
+  getProviderConfig,
+  saveConfig
+};
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */