@butlerw/vellum 0.1.0

package/dist/chunk-SECXJGWA.js

@@ -0,0 +1,597 @@
+// src/commands/auth.ts
+import {
+  CredentialManager,
+  EncryptedFileStore,
+  EnvCredentialStore,
+  KeychainStore
+} from "@vellum/core";
+
+// src/commands/types.ts
+function success(message, data) {
+  return { kind: "success", message, data };
+}
+function error(code, message, suggestions) {
+  return { kind: "error", code, message, suggestions };
+}
+function interactive(prompt) {
+  return { kind: "interactive", prompt };
+}
+function pending(operation) {
+  return { kind: "pending", operation };
+}
+
+// src/commands/auth.ts
+async function createCredentialManager() {
+  const stores = [
+    new EnvCredentialStore(),
+    new KeychainStore(),
+    new EncryptedFileStore({
+      filePath: `${process.env.HOME ?? process.env.USERPROFILE}/.vellum/credentials.enc`,
+      password: process.env.VELLUM_CREDENTIAL_PASSWORD ?? "vellum-default-key"
+    })
+  ];
+  return new CredentialManager(stores, {
+    preferredWriteStore: "keychain"
+  });
+}
+async function handleCredentials(args, context) {
+  const filterProvider = args[0]?.toLowerCase();
+  try {
+    const availability = await context.credentialManager.getStoreAvailability();
+    const listResult = await context.credentialManager.list(filterProvider);
+    if (!listResult.ok) {
+      return {
+        success: false,
+        message: `\u274C Failed to list credentials: ${listResult.error.message}`
+      };
+    }
+    const credentials = listResult.value;
+    const lines = [];
+    lines.push("\u{1F510} Credential Status");
+    lines.push("\u2501".repeat(40));
+    lines.push("\n\u{1F4E6} Storage Backends:");
+    for (const [store, available] of Object.entries(availability)) {
+      lines.push(`   ${available ? "\u2713" : "\u2717"} ${store}`);
+    }
+    lines.push("\n\u{1F511} Credentials:");
+    if (credentials.length === 0) {
+      if (filterProvider) {
+        lines.push(`   No credential found for ${filterProvider}`);
+      } else {
+        lines.push("   No credentials stored");
+        lines.push("   Use /auth set <provider> to add one");
+      }
+    } else {
+      for (const cred of credentials) {
+        const maskedValue = cred.maskedHint ?? "***";
+        lines.push(`   \u2022 ${cred.provider} (${cred.source}): ${maskedValue} [${cred.type}]`);
+      }
+    }
+    lines.push("\u2501".repeat(40));
+    return {
+      success: true,
+      message: lines.join("\n"),
+      data: {
+        availability,
+        credentials: credentials.map((c) => ({
+          provider: c.provider,
+          source: c.source,
+          type: c.type,
+          maskedHint: c.maskedHint
+        }))
+      }
+    };
+  } catch (err) {
+    return {
+      success: false,
+      message: `\u274C Error: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+}
+var authSlashCommands = [
+  {
+    name: "credentials",
+    aliases: ["creds", "keys"],
+    description: "Show credential status",
+    usage: "/credentials [provider]",
+    handler: handleCredentials
+  }
+];
+var credentialsCommand = {
+  name: "credentials",
+  description: "Show credential status and available stores",
+  kind: "builtin",
+  category: "auth",
+  aliases: ["creds", "keys"],
+  positionalArgs: [
+    {
+      name: "provider",
+      type: "string",
+      description: "Filter by provider name",
+      required: false
+    }
+  ],
+  namedArgs: [],
+  examples: ["/credentials", "/credentials anthropic", "/creds"],
+  execute: async (ctx) => {
+    const filterProvider = ctx.parsedArgs.positional[0];
+    const normalizedFilter = filterProvider?.toLowerCase();
+    try {
+      const availability = await ctx.credentials.getStoreAvailability();
+      const listResult = await ctx.credentials.list(normalizedFilter);
+      if (!listResult.ok) {
+        return error(
+          "INTERNAL_ERROR",
+          `\u274C Failed to list credentials: ${listResult.error.message}`
+        );
+      }
+      const credentials = listResult.value;
+      const lines = [];
+      lines.push("\u{1F510} Credential Status");
+      lines.push("\u2501".repeat(40));
+      lines.push("\n\u{1F4E6} Storage Backends:");
+      for (const [store, available] of Object.entries(availability)) {
+        lines.push(`   ${available ? "\u2713" : "\u2717"} ${store}`);
+      }
+      lines.push("\n\u{1F511} Credentials:");
+      if (credentials.length === 0) {
+        if (normalizedFilter) {
+          lines.push(`   No credential found for ${normalizedFilter}`);
+        } else {
+          lines.push("   No credentials stored");
+          lines.push("   Use /auth set <provider> to add one");
+        }
+      } else {
+        for (const cred of credentials) {
+          const maskedValue = cred.maskedHint ?? "***";
+          lines.push(`   \u2022 ${cred.provider} (${cred.source}): ${maskedValue} [${cred.type}]`);
+        }
+      }
+      lines.push("\u2501".repeat(40));
+      return success(lines.join("\n"), {
+        availability,
+        credentials: credentials.map((c) => ({
+          provider: c.provider,
+          source: c.source,
+          type: c.type,
+          maskedHint: c.maskedHint
+        }))
+      });
+    } catch (err) {
+      return error(
+        "INTERNAL_ERROR",
+        `\u274C Error: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+};
+var authCommand = {
+  name: "auth",
+  description: "Manage API credentials (status, set, clear)",
+  kind: "builtin",
+  category: "auth",
+  aliases: [],
+  subcommands: [
+    {
+      name: "status",
+      description: "Show current authentication status (default)",
+      aliases: ["st", "list"]
+    },
+    {
+      name: "set",
+      description: "Add or update API credential for a provider",
+      aliases: ["add", "login"]
+    },
+    {
+      name: "clear",
+      description: "Remove credential for a provider",
+      aliases: ["remove", "delete", "logout"]
+    }
+  ],
+  positionalArgs: [
+    {
+      name: "subcommand",
+      type: "string",
+      description: "Subcommand: status, set, clear (default: status)",
+      required: false
+    },
+    {
+      name: "provider",
+      type: "string",
+      description: "Provider name (e.g., anthropic, openai)",
+      required: false
+    }
+  ],
+  namedArgs: [
+    {
+      name: "store",
+      shorthand: "s",
+      type: "string",
+      description: "Credential store to use (keychain, encrypted-file, env)",
+      required: false,
+      default: "keychain"
+    },
+    {
+      name: "force",
+      shorthand: "f",
+      type: "boolean",
+      description: "Skip confirmation prompt for clear",
+      required: false,
+      default: false
+    }
+  ],
+  examples: [
+    "/auth",
+    "/auth status",
+    "/auth set anthropic",
+    "/auth set openai --store keychain",
+    "/auth clear anthropic",
+    "/auth clear openai --force"
+  ],
+  execute: async (ctx) => {
+    const args = ctx.parsedArgs.positional;
+    const subcommand = args[0]?.toLowerCase() ?? "status";
+    const provider = args[1] ?? // If subcommand is a provider name (not a known subcommand), treat it as provider
+    (![
+      "status",
+      "st",
+      "list",
+      "set",
+      "add",
+      "login",
+      "clear",
+      "remove",
+      "delete",
+      "logout"
+    ].includes(subcommand) ? subcommand : void 0);
+    const store = ctx.parsedArgs.named.store;
+    const force = ctx.parsedArgs.named.force === true;
+    const actualSubcommand = [
+      "status",
+      "st",
+      "list",
+      "set",
+      "add",
+      "login",
+      "clear",
+      "remove",
+      "delete",
+      "logout"
+    ].includes(subcommand) ? subcommand : "status";
+    switch (actualSubcommand) {
+      case "set":
+      case "add":
+      case "login":
+        return authSet(ctx.credentials, provider ?? ctx.session.provider, store);
+      case "clear":
+      case "remove":
+      case "delete":
+      case "logout":
+        return authClear(ctx.credentials, provider ?? ctx.session.provider, force);
+      default:
+        return authStatus(ctx.credentials, provider);
+    }
+  }
+};
+async function authStatus(credentials, filterProvider) {
+  const normalizedFilter = filterProvider?.toLowerCase();
+  try {
+    const availability = await credentials.getStoreAvailability();
+    const listResult = await credentials.list(normalizedFilter);
+    if (!listResult.ok) {
+      return error("INTERNAL_ERROR", `\u274C Failed to list credentials: ${listResult.error.message}`);
+    }
+    const credentialsList = listResult.value;
+    const lines = [];
+    lines.push("\u{1F510} Authentication Status");
+    lines.push("\u2501".repeat(40));
+    lines.push("\n\u{1F4E6} Storage Backends:");
+    for (const [store, available] of Object.entries(availability)) {
+      lines.push(`   ${available ? "\u2713" : "\u2717"} ${store}`);
+    }
+    lines.push("\n\u{1F511} Configured Providers:");
+    if (credentialsList.length === 0) {
+      if (normalizedFilter) {
+        lines.push(`   No credential found for ${normalizedFilter}`);
+      } else {
+        lines.push("   No credentials stored");
+        lines.push("   Use /auth set <provider> to add one");
+      }
+    } else {
+      for (const cred of credentialsList) {
+        const maskedValue = cred.maskedHint ?? "***";
+        lines.push(`   \u2022 ${cred.provider} (${cred.source}): ${maskedValue} [${cred.type}]`);
+      }
+    }
+    lines.push(`
+${"\u2501".repeat(40)}`);
+    lines.push("\u{1F4A1} Commands: /auth set <provider> | /auth clear <provider>");
+    return success(lines.join("\n"), {
+      availability,
+      credentials: credentialsList.map((c) => ({
+        provider: c.provider,
+        source: c.source,
+        type: c.type,
+        maskedHint: c.maskedHint
+      }))
+    });
+  } catch (err) {
+    return error("INTERNAL_ERROR", `\u274C Error: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+var PROVIDER_KEY_HINTS = {
+  anthropic: {
+    formatHint: "sk-ant-api03-...",
+    helpText: "Your Anthropic key starts with sk-ant-",
+    documentationUrl: "https://console.anthropic.com/settings/keys"
+  },
+  openai: {
+    formatHint: "sk-proj-...",
+    helpText: "Your OpenAI key starts with sk-proj- or sk-",
+    documentationUrl: "https://platform.openai.com/api-keys"
+  },
+  google: {
+    formatHint: "AIza...",
+    helpText: "Your Google AI key starts with AIza",
+    documentationUrl: "https://aistudio.google.com/apikey"
+  },
+  gemini: {
+    formatHint: "AIza...",
+    helpText: "Your Gemini key starts with AIza",
+    documentationUrl: "https://aistudio.google.com/apikey"
+  },
+  bedrock: {
+    formatHint: "AKIA...",
+    helpText: "Enter your AWS access key ID",
+    documentationUrl: "https://docs.aws.amazon.com/bedrock/latest/userguide/setting-up.html"
+  },
+  cohere: {
+    formatHint: "...",
+    helpText: "Your Cohere API key",
+    documentationUrl: "https://dashboard.cohere.com/api-keys"
+  },
+  mistral: {
+    formatHint: "...",
+    helpText: "Your Mistral API key",
+    documentationUrl: "https://console.mistral.ai/api-keys"
+  },
+  groq: {
+    formatHint: "gsk_...",
+    helpText: "Your Groq key starts with gsk_",
+    documentationUrl: "https://console.groq.com/keys"
+  },
+  fireworks: {
+    formatHint: "fw_...",
+    helpText: "Your Fireworks key starts with fw_",
+    documentationUrl: "https://fireworks.ai/account/api-keys"
+  },
+  together: {
+    formatHint: "...",
+    helpText: "Your Together AI API key",
+    documentationUrl: "https://api.together.xyz/settings/api-keys"
+  },
+  perplexity: {
+    formatHint: "pplx-...",
+    helpText: "Your Perplexity key starts with pplx-",
+    documentationUrl: "https://www.perplexity.ai/settings/api"
+  },
+  deepseek: {
+    formatHint: "sk-...",
+    helpText: "Your DeepSeek API key",
+    documentationUrl: "https://platform.deepseek.com/api_keys"
+  },
+  openrouter: {
+    formatHint: "sk-or-...",
+    helpText: "Your OpenRouter key starts with sk-or-",
+    documentationUrl: "https://openrouter.ai/keys"
+  },
+  ollama: {
+    formatHint: "(optional)",
+    helpText: "Ollama typically runs locally without an API key"
+  }
+};
+function getProviderHints(provider) {
+  return PROVIDER_KEY_HINTS[provider] ?? {
+    formatHint: "...",
+    helpText: `Enter your ${provider} API key`
+  };
+}
+async function authSet(credentials, provider, store) {
+  if (!provider) {
+    return error(
+      "MISSING_ARGUMENT",
+      "\u274C Provider required. Usage: /auth set <provider>\n   Example: /auth set anthropic"
+    );
+  }
+  const normalizedProvider = provider.toLowerCase();
+  const existsResult = await credentials.exists(normalizedProvider);
+  const alreadyExists = existsResult.ok && existsResult.value;
+  const hints = getProviderHints(normalizedProvider);
+  const displayName = normalizedProvider.charAt(0).toUpperCase() + normalizedProvider.slice(1);
+  const title = alreadyExists ? `\u{1F510} Update API Key for ${displayName}` : `\u{1F510} Set API Key for ${displayName}`;
+  const promptMessage = `${displayName} API Key:`;
+  return interactive({
+    inputType: "password",
+    message: promptMessage,
+    placeholder: hints.formatHint,
+    provider: normalizedProvider,
+    title,
+    helpText: hints.helpText,
+    formatHint: hints.formatHint,
+    documentationUrl: hints.documentationUrl,
+    handler: async (value) => {
+      if (!value.trim()) {
+        return error("INVALID_ARGUMENT", "\u274C API key cannot be empty");
+      }
+      try {
+        const result = await credentials.store(
+          {
+            provider: normalizedProvider,
+            type: "api_key",
+            value: value.trim(),
+            metadata: {
+              label: `${normalizedProvider} API Key`
+            }
+          },
+          store
+        );
+        if (!result.ok) {
+          return error("INTERNAL_ERROR", `\u274C Failed to save credential: ${result.error.message}`);
+        }
+        return success(`\u2705 Credential for ${normalizedProvider} saved to ${result.value.source}`, {
+          provider: normalizedProvider,
+          source: result.value.source
+        });
+      } catch (err) {
+        return error(
+          "INTERNAL_ERROR",
+          `\u274C Error: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    },
+    onCancel: () => ({
+      kind: "error",
+      code: "COMMAND_ABORTED",
+      message: "Credential setup cancelled"
+    })
+  });
+}
+async function authClear(credentials, provider, force) {
+  if (!provider) {
+    return error(
+      "MISSING_ARGUMENT",
+      "\u274C Provider required. Usage: /auth clear <provider>\n   Example: /auth clear anthropic"
+    );
+  }
+  const normalizedProvider = provider.toLowerCase();
+  const existsResult = await credentials.exists(normalizedProvider);
+  if (!existsResult.ok || !existsResult.value) {
+    return error("CREDENTIAL_NOT_FOUND", `\u26A0\uFE0F No credential found for ${normalizedProvider}`);
+  }
+  if (!force) {
+    return interactive({
+      inputType: "confirm",
+      message: `Are you sure you want to remove credential for ${normalizedProvider}?`,
+      handler: async (value) => {
+        if (value.toLowerCase() !== "yes" && value.toLowerCase() !== "y") {
+          return error("COMMAND_ABORTED", "Credential removal cancelled");
+        }
+        return performAuthClear(credentials, normalizedProvider);
+      },
+      onCancel: () => ({
+        kind: "error",
+        code: "COMMAND_ABORTED",
+        message: "Credential removal cancelled"
+      })
+    });
+  }
+  return performAuthClear(credentials, normalizedProvider);
+}
+async function performAuthClear(credentials, provider) {
+  try {
+    const result = await credentials.delete(provider);
+    if (!result.ok) {
+      return error("INTERNAL_ERROR", `\u274C Failed to remove credential: ${result.error.message}`);
+    }
+    if (result.value === 0) {
+      return error("CREDENTIAL_NOT_FOUND", `\u26A0\uFE0F No credential found for ${provider}`);
+    }
+    return success(`\u2705 Credential for ${provider} removed from ${result.value} store(s)`, {
+      provider,
+      deletedCount: result.value
+    });
+  } catch (err) {
+    return error("INTERNAL_ERROR", `\u274C Error: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+var enhancedAuthCommands = [authCommand, credentialsCommand];
+function isSlashCommand(input) {
+  return input.trim().startsWith("/");
+}
+function parseSlashCommand(input) {
+  const trimmed = input.trim();
+  if (!trimmed.startsWith("/")) {
+    return null;
+  }
+  const parts = trimmed.slice(1).split(/\s+/);
+  const command = parts[0]?.toLowerCase() ?? "";
+  const args = parts.slice(1);
+  return { command, args };
+}
+function findSlashCommand(name) {
+  const lowerName = name.toLowerCase();
+  return authSlashCommands.find(
+    (cmd) => cmd.name === lowerName || cmd.aliases?.includes(lowerName)
+  );
+}
+async function executeSlashCommand(input, context = {}) {
+  const parsed = parseSlashCommand(input);
+  if (!parsed) {
+    return {
+      success: false,
+      message: "Invalid slash command format"
+    };
+  }
+  const command = findSlashCommand(parsed.command);
+  if (!command) {
+    if (parsed.command === "help" && parsed.args[0]) {
+      const helpCmd = findSlashCommand(parsed.args[0]);
+      if (helpCmd) {
+        return {
+          success: true,
+          message: `\u{1F4D6} ${helpCmd.name}
+   ${helpCmd.description}
+   Usage: ${helpCmd.usage}`
+        };
+      }
+    }
+    const available = authSlashCommands.map((c) => `/${c.name}`).join(", ");
+    return {
+      success: false,
+      message: `\u2753 Unknown command: /${parsed.command}
+   Available: ${available}`
+    };
+  }
+  const credentialManager = context.credentialManager ?? await createCredentialManager();
+  const fullContext = {
+    currentProvider: context.currentProvider,
+    credentialManager
+  };
+  return command.handler(parsed.args, fullContext);
+}
+function getSlashCommandHelp() {
+  const lines = [];
+  lines.push("\u{1F4D6} Available Commands:");
+  lines.push("\u2501".repeat(40));
+  for (const cmd of authSlashCommands) {
+    lines.push(`
+/${cmd.name}`);
+    if (cmd.aliases?.length) {
+      lines.push(`   Aliases: ${cmd.aliases.map((a) => `/${a}`).join(", ")}`);
+    }
+    lines.push(`   ${cmd.description}`);
+    lines.push(`   Usage: ${cmd.usage}`);
+  }
+  lines.push(`
+${"\u2501".repeat(40)}`);
+  lines.push("Tip: Use /help <command> for detailed help");
+  return lines.join("\n");
+}
+
+export {
+  success,
+  error,
+  interactive,
+  pending,
+  createCredentialManager,
+  handleCredentials,
+  authSlashCommands,
+  credentialsCommand,
+  authCommand,
+  enhancedAuthCommands,
+  isSlashCommand,
+  parseSlashCommand,
+  findSlashCommand,
+  executeSlashCommand,
+  getSlashCommandHelp
+};