vellum 0.0.16 → 0.2.0

package/dist/cli.js

@@ -1,569 +0,0 @@
-#!/usr/bin/env bun
-// @bun
-var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __toESM = (mod, isNodeMode, target) => {
-  target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: () => mod[key],
-        enumerable: true
-      });
-  return to;
-};
-var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
-var __require = import.meta.require;
-
-// node_modules/dotenv/package.json
-var require_package = __commonJS((exports, module) => {
-  module.exports = {
-    name: "dotenv",
-    version: "17.3.1",
-    description: "Loads environment variables from .env file",
-    main: "lib/main.js",
-    types: "lib/main.d.ts",
-    exports: {
-      ".": {
-        types: "./lib/main.d.ts",
-        require: "./lib/main.js",
-        default: "./lib/main.js"
-      },
-      "./config": "./config.js",
-      "./config.js": "./config.js",
-      "./lib/env-options": "./lib/env-options.js",
-      "./lib/env-options.js": "./lib/env-options.js",
-      "./lib/cli-options": "./lib/cli-options.js",
-      "./lib/cli-options.js": "./lib/cli-options.js",
-      "./package.json": "./package.json"
-    },
-    scripts: {
-      "dts-check": "tsc --project tests/types/tsconfig.json",
-      lint: "standard",
-      pretest: "npm run lint && npm run dts-check",
-      test: "tap run tests/**/*.js --allow-empty-coverage --disable-coverage --timeout=60000",
-      "test:coverage": "tap run tests/**/*.js --show-full-coverage --timeout=60000 --coverage-report=text --coverage-report=lcov",
-      prerelease: "npm test",
-      release: "standard-version"
-    },
-    repository: {
-      type: "git",
-      url: "git://github.com/motdotla/dotenv.git"
-    },
-    homepage: "https://github.com/motdotla/dotenv#readme",
-    funding: "https://dotenvx.com",
-    keywords: [
-      "dotenv",
-      "env",
-      ".env",
-      "environment",
-      "variables",
-      "config",
-      "settings"
-    ],
-    readmeFilename: "README.md",
-    license: "BSD-2-Clause",
-    devDependencies: {
-      "@types/node": "^18.11.3",
-      decache: "^4.6.2",
-      sinon: "^14.0.1",
-      standard: "^17.0.0",
-      "standard-version": "^9.5.0",
-      tap: "^19.2.0",
-      typescript: "^4.8.4"
-    },
-    engines: {
-      node: ">=12"
-    },
-    browser: {
-      fs: false
-    }
-  };
-});
-
-// node_modules/dotenv/lib/main.js
-var require_main = __commonJS((exports, module) => {
-  var fs = __require("fs");
-  var path = __require("path");
-  var os = __require("os");
-  var crypto = __require("crypto");
-  var packageJson = require_package();
-  var version = packageJson.version;
-  var TIPS = [
-    "\uD83D\uDD10 encrypt with Dotenvx: https://dotenvx.com",
-    "\uD83D\uDD10 prevent committing .env to code: https://dotenvx.com/precommit",
-    "\uD83D\uDD10 prevent building .env in docker: https://dotenvx.com/prebuild",
-    "\uD83E\uDD16 agentic secret storage: https://dotenvx.com/as2",
-    "\u26A1\uFE0F secrets for agents: https://dotenvx.com/as2",
-    "\uD83D\uDEE1\uFE0F auth for agents: https://vestauth.com",
-    "\uD83D\uDEE0\uFE0F  run anywhere with `dotenvx run -- yourcommand`",
-    "\u2699\uFE0F  specify custom .env file path with { path: '/custom/path/.env' }",
-    "\u2699\uFE0F  enable debug logging with { debug: true }",
-    "\u2699\uFE0F  override existing env vars with { override: true }",
-    "\u2699\uFE0F  suppress all logs with { quiet: true }",
-    "\u2699\uFE0F  write to custom object with { processEnv: myObject }",
-    "\u2699\uFE0F  load multiple .env files with { path: ['.env.local', '.env'] }"
-  ];
-  function _getRandomTip() {
-    return TIPS[Math.floor(Math.random() * TIPS.length)];
-  }
-  function parseBoolean(value) {
-    if (typeof value === "string") {
-      return !["false", "0", "no", "off", ""].includes(value.toLowerCase());
-    }
-    return Boolean(value);
-  }
-  function supportsAnsi() {
-    return process.stdout.isTTY;
-  }
-  function dim(text) {
-    return supportsAnsi() ? `\x1B[2m${text}\x1B[0m` : text;
-  }
-  var LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg;
-  function parse(src) {
-    const obj = {};
-    let lines = src.toString();
-    lines = lines.replace(/\r\n?/mg, `
-`);
-    let match;
-    while ((match = LINE.exec(lines)) != null) {
-      const key = match[1];
-      let value = match[2] || "";
-      value = value.trim();
-      const maybeQuote = value[0];
-      value = value.replace(/^(['"`])([\s\S]*)\1$/mg, "$2");
-      if (maybeQuote === '"') {
-        value = value.replace(/\\n/g, `
-`);
-        value = value.replace(/\\r/g, "\r");
-      }
-      obj[key] = value;
-    }
-    return obj;
-  }
-  function _parseVault(options) {
-    options = options || {};
-    const vaultPath = _vaultPath(options);
-    options.path = vaultPath;
-    const result = DotenvModule.configDotenv(options);
-    if (!result.parsed) {
-      const err = new Error(`MISSING_DATA: Cannot parse ${vaultPath} for an unknown reason`);
-      err.code = "MISSING_DATA";
-      throw err;
-    }
-    const keys = _dotenvKey(options).split(",");
-    const length = keys.length;
-    let decrypted;
-    for (let i = 0;i < length; i++) {
-      try {
-        const key = keys[i].trim();
-        const attrs = _instructions(result, key);
-        decrypted = DotenvModule.decrypt(attrs.ciphertext, attrs.key);
-        break;
-      } catch (error) {
-        if (i + 1 >= length) {
-          throw error;
-        }
-      }
-    }
-    return DotenvModule.parse(decrypted);
-  }
-  function _warn(message) {
-    console.error(`[dotenv@${version}][WARN] ${message}`);
-  }
-  function _debug(message) {
-    console.log(`[dotenv@${version}][DEBUG] ${message}`);
-  }
-  function _log(message) {
-    console.log(`[dotenv@${version}] ${message}`);
-  }
-  function _dotenvKey(options) {
-    if (options && options.DOTENV_KEY && options.DOTENV_KEY.length > 0) {
-      return options.DOTENV_KEY;
-    }
-    if (process.env.DOTENV_KEY && process.env.DOTENV_KEY.length > 0) {
-      return process.env.DOTENV_KEY;
-    }
-    return "";
-  }
-  function _instructions(result, dotenvKey) {
-    let uri;
-    try {
-      uri = new URL(dotenvKey);
-    } catch (error) {
-      if (error.code === "ERR_INVALID_URL") {
-        const err = new Error("INVALID_DOTENV_KEY: Wrong format. Must be in valid uri format like dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=development");
-        err.code = "INVALID_DOTENV_KEY";
-        throw err;
-      }
-      throw error;
-    }
-    const key = uri.password;
-    if (!key) {
-      const err = new Error("INVALID_DOTENV_KEY: Missing key part");
-      err.code = "INVALID_DOTENV_KEY";
-      throw err;
-    }
-    const environment = uri.searchParams.get("environment");
-    if (!environment) {
-      const err = new Error("INVALID_DOTENV_KEY: Missing environment part");
-      err.code = "INVALID_DOTENV_KEY";
-      throw err;
-    }
-    const environmentKey = `DOTENV_VAULT_${environment.toUpperCase()}`;
-    const ciphertext = result.parsed[environmentKey];
-    if (!ciphertext) {
-      const err = new Error(`NOT_FOUND_DOTENV_ENVIRONMENT: Cannot locate environment ${environmentKey} in your .env.vault file.`);
-      err.code = "NOT_FOUND_DOTENV_ENVIRONMENT";
-      throw err;
-    }
-    return { ciphertext, key };
-  }
-  function _vaultPath(options) {
-    let possibleVaultPath = null;
-    if (options && options.path && options.path.length > 0) {
-      if (Array.isArray(options.path)) {
-        for (const filepath of options.path) {
-          if (fs.existsSync(filepath)) {
-            possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`;
-          }
-        }
-      } else {
-        possibleVaultPath = options.path.endsWith(".vault") ? options.path : `${options.path}.vault`;
-      }
-    } else {
-      possibleVaultPath = path.resolve(process.cwd(), ".env.vault");
-    }
-    if (fs.existsSync(possibleVaultPath)) {
-      return possibleVaultPath;
-    }
-    return null;
-  }
-  function _resolveHome(envPath) {
-    return envPath[0] === "~" ? path.join(os.homedir(), envPath.slice(1)) : envPath;
-  }
-  function _configVault(options) {
-    const debug = parseBoolean(process.env.DOTENV_CONFIG_DEBUG || options && options.debug);
-    const quiet = parseBoolean(process.env.DOTENV_CONFIG_QUIET || options && options.quiet);
-    if (debug || !quiet) {
-      _log("Loading env from encrypted .env.vault");
-    }
-    const parsed = DotenvModule._parseVault(options);
-    let processEnv = process.env;
-    if (options && options.processEnv != null) {
-      processEnv = options.processEnv;
-    }
-    DotenvModule.populate(processEnv, parsed, options);
-    return { parsed };
-  }
-  function configDotenv(options) {
-    const dotenvPath = path.resolve(process.cwd(), ".env");
-    let encoding = "utf8";
-    let processEnv = process.env;
-    if (options && options.processEnv != null) {
-      processEnv = options.processEnv;
-    }
-    let debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || options && options.debug);
-    let quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || options && options.quiet);
-    if (options && options.encoding) {
-      encoding = options.encoding;
-    } else {
-      if (debug) {
-        _debug("No encoding is specified. UTF-8 is used by default");
-      }
-    }
-    let optionPaths = [dotenvPath];
-    if (options && options.path) {
-      if (!Array.isArray(options.path)) {
-        optionPaths = [_resolveHome(options.path)];
-      } else {
-        optionPaths = [];
-        for (const filepath of options.path) {
-          optionPaths.push(_resolveHome(filepath));
-        }
-      }
-    }
-    let lastError;
-    const parsedAll = {};
-    for (const path2 of optionPaths) {
-      try {
-        const parsed = DotenvModule.parse(fs.readFileSync(path2, { encoding }));
-        DotenvModule.populate(parsedAll, parsed, options);
-      } catch (e) {
-        if (debug) {
-          _debug(`Failed to load ${path2} ${e.message}`);
-        }
-        lastError = e;
-      }
-    }
-    const populated = DotenvModule.populate(processEnv, parsedAll, options);
-    debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || debug);
-    quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || quiet);
-    if (debug || !quiet) {
-      const keysCount = Object.keys(populated).length;
-      const shortPaths = [];
-      for (const filePath of optionPaths) {
-        try {
-          const relative = path.relative(process.cwd(), filePath);
-          shortPaths.push(relative);
-        } catch (e) {
-          if (debug) {
-            _debug(`Failed to load ${filePath} ${e.message}`);
-          }
-          lastError = e;
-        }
-      }
-      _log(`injecting env (${keysCount}) from ${shortPaths.join(",")} ${dim(`-- tip: ${_getRandomTip()}`)}`);
-    }
-    if (lastError) {
-      return { parsed: parsedAll, error: lastError };
-    } else {
-      return { parsed: parsedAll };
-    }
-  }
-  function config(options) {
-    if (_dotenvKey(options).length === 0) {
-      return DotenvModule.configDotenv(options);
-    }
-    const vaultPath = _vaultPath(options);
-    if (!vaultPath) {
-      _warn(`You set DOTENV_KEY but you are missing a .env.vault file at ${vaultPath}. Did you forget to build it?`);
-      return DotenvModule.configDotenv(options);
-    }
-    return DotenvModule._configVault(options);
-  }
-  function decrypt(encrypted, keyStr) {
-    const key = Buffer.from(keyStr.slice(-64), "hex");
-    let ciphertext = Buffer.from(encrypted, "base64");
-    const nonce = ciphertext.subarray(0, 12);
-    const authTag = ciphertext.subarray(-16);
-    ciphertext = ciphertext.subarray(12, -16);
-    try {
-      const aesgcm = crypto.createDecipheriv("aes-256-gcm", key, nonce);
-      aesgcm.setAuthTag(authTag);
-      return `${aesgcm.update(ciphertext)}${aesgcm.final()}`;
-    } catch (error) {
-      const isRange = error instanceof RangeError;
-      const invalidKeyLength = error.message === "Invalid key length";
-      const decryptionFailed = error.message === "Unsupported state or unable to authenticate data";
-      if (isRange || invalidKeyLength) {
-        const err = new Error("INVALID_DOTENV_KEY: It must be 64 characters long (or more)");
-        err.code = "INVALID_DOTENV_KEY";
-        throw err;
-      } else if (decryptionFailed) {
-        const err = new Error("DECRYPTION_FAILED: Please check your DOTENV_KEY");
-        err.code = "DECRYPTION_FAILED";
-        throw err;
-      } else {
-        throw error;
-      }
-    }
-  }
-  function populate(processEnv, parsed, options = {}) {
-    const debug = Boolean(options && options.debug);
-    const override = Boolean(options && options.override);
-    const populated = {};
-    if (typeof parsed !== "object") {
-      const err = new Error("OBJECT_REQUIRED: Please check the processEnv argument being passed to populate");
-      err.code = "OBJECT_REQUIRED";
-      throw err;
-    }
-    for (const key of Object.keys(parsed)) {
-      if (Object.prototype.hasOwnProperty.call(processEnv, key)) {
-        if (override === true) {
-          processEnv[key] = parsed[key];
-          populated[key] = parsed[key];
-        }
-        if (debug) {
-          if (override === true) {
-            _debug(`"${key}" is already defined and WAS overwritten`);
-          } else {
-            _debug(`"${key}" is already defined and was NOT overwritten`);
-          }
-        }
-      } else {
-        processEnv[key] = parsed[key];
-        populated[key] = parsed[key];
-      }
-    }
-    return populated;
-  }
-  var DotenvModule = {
-    configDotenv,
-    _configVault,
-    _parseVault,
-    config,
-    decrypt,
-    parse,
-    populate
-  };
-  exports.configDotenv = DotenvModule.configDotenv;
-  exports._configVault = DotenvModule._configVault;
-  exports._parseVault = DotenvModule._parseVault;
-  exports.config = DotenvModule.config;
-  exports.decrypt = DotenvModule.decrypt;
-  exports.parse = DotenvModule.parse;
-  exports.populate = DotenvModule.populate;
-  module.exports = DotenvModule;
-});
-
-// src/cli.ts
-var import_dotenv = __toESM(require_main(), 1);
-import { execSync, spawn } from "child_process";
-import fs from "fs";
-import os from "os";
-import path from "path";
-var REPO = "vellum-ai/velly";
-var INSTALL_DIR = path.join(os.homedir(), ".local", "share", "vellum");
-var DOTENV_PATH = path.join(os.homedir(), ".vellum", ".env");
-function loadDotenv() {
-  try {
-    const parsed = import_dotenv.default.parse(fs.readFileSync(DOTENV_PATH, "utf-8"));
-    return parsed;
-  } catch {
-    return {};
-  }
-}
-async function fetchLatestRelease() {
-  const res = await fetch(`https://api.github.com/repos/${REPO}/releases/latest`, {
-    headers: {
-      Accept: "application/vnd.github+json"
-    }
-  });
-  if (!res.ok) {
-    throw new Error(`Failed to fetch latest release: ${res.status} ${await res.text()}`);
-  }
-  return res.json();
-}
-var RETRYABLE_STATUS_CODES = new Set([502, 503, 504]);
-var MAX_RETRIES = 3;
-var RETRY_BASE_DELAY_MS = 2000;
-async function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-async function downloadAsset(url, destPath, name) {
-  for (let attempt = 1;attempt <= MAX_RETRIES; attempt++) {
-    const res = await fetch(url);
-    if (res.ok) {
-      const buffer = await res.arrayBuffer();
-      fs.writeFileSync(destPath, Buffer.from(buffer));
-      return;
-    }
-    if (RETRYABLE_STATUS_CODES.has(res.status) && attempt < MAX_RETRIES) {
-      const delay = RETRY_BASE_DELAY_MS * 2 ** (attempt - 1);
-      console.warn(`Failed to download ${name} (HTTP ${res.status}), retrying in ${delay / 1000}s (attempt ${attempt}/${MAX_RETRIES})...`);
-      await sleep(delay);
-      continue;
-    }
-    throw new Error(`Failed to download ${name}: HTTP ${res.status}`);
-  }
-}
-function findAssetOrThrow(release, prefix) {
-  const asset = release.assets.find((a) => a.name.startsWith(prefix));
-  if (!asset) {
-    throw new Error(`No ${prefix} artifact found in release ${release.tag_name}`);
-  }
-  return asset;
-}
-async function extractAsset(url, tmpDir, name) {
-  const zipPath = path.join(tmpDir, `${name}.zip`);
-  const destDir = path.join(tmpDir, name);
-  await downloadAsset(url, zipPath, name);
-  console.log(`Extracting ${name}...`);
-  fs.mkdirSync(destDir, { recursive: true });
-  execSync(`unzip -q "${zipPath}" -d "${destDir}"`, { stdio: "inherit" });
-  fs.rmSync(zipPath);
-  console.log(`Installing ${name} dependencies...`);
-  execSync("bun install", { cwd: destDir, stdio: "inherit" });
-  return destDir;
-}
-function linkBun() {
-  const bunPath = execSync("which bun", { encoding: "utf-8" }).trim();
-  const binDir = path.join(os.homedir(), ".local", "bin");
-  const linkPath = path.join(binDir, "bun");
-  fs.mkdirSync(binDir, { recursive: true });
-  if (bunPath !== linkPath) {
-    fs.copyFileSync(bunPath, linkPath);
-    fs.chmodSync(linkPath, 493);
-    console.log(`Linked bun to ${linkPath}`);
-  }
-}
-function linkVellumCli(assistantDir) {
-  const entryPoint = path.join(assistantDir, "src", "index.ts");
-  const binDir = path.join(os.homedir(), ".local", "bin");
-  const bunPath = path.join(binDir, "bun");
-  const wrapper = `#!/bin/bash
-exec "${bunPath}" run "${entryPoint}" "$@"
-`;
-  const linkPath = path.join(binDir, "vellum");
-  fs.mkdirSync(binDir, { recursive: true });
-  fs.writeFileSync(linkPath, wrapper, { mode: 493 });
-  console.log(`Linked vellum CLI to ${linkPath}`);
-}
-async function hatch() {
-  console.log("Fetching latest release...");
-  const release = await fetchLatestRelease();
-  const assistantAsset = findAssetOrThrow(release, "assistant");
-  const cliAsset = findAssetOrThrow(release, "cli");
-  const gatewayAsset = findAssetOrThrow(release, "gateway");
-  if (fs.existsSync(INSTALL_DIR)) {
-    fs.rmSync(INSTALL_DIR, { recursive: true, force: true });
-  }
-  fs.mkdirSync(INSTALL_DIR, { recursive: true });
-  try {
-    console.log(`Downloading assets from ${release.tag_name}...`);
-    const [assistantDir, , gatewayDir] = await Promise.all([
-      extractAsset(assistantAsset.browser_download_url, INSTALL_DIR, "assistant"),
-      extractAsset(cliAsset.browser_download_url, INSTALL_DIR, "cli"),
-      extractAsset(gatewayAsset.browser_download_url, INSTALL_DIR, "gateway")
-    ]);
-    linkBun();
-    linkVellumCli(assistantDir);
-    console.log("Starting assistant daemon...");
-    await new Promise((resolve, reject) => {
-      const child = spawn("bun", ["run", "src/index.ts", "daemon", "start"], {
-        cwd: assistantDir,
-        stdio: "inherit",
-        env: { ...process.env, RUNTIME_HTTP_PORT: "7821" }
-      });
-      child.on("exit", (code) => {
-        if (code === 0)
-          resolve();
-        else
-          reject(new Error(`Daemon start exited with code ${code}`));
-      });
-      child.on("error", reject);
-    });
-    console.log("Starting gateway...");
-    const vellumDir = path.join(os.homedir(), ".vellum");
-    fs.mkdirSync(vellumDir, { recursive: true });
-    const dotenvVars = loadDotenv();
-    const gatewayLogPath = path.join(vellumDir, "http-gateway.log");
-    const logFd = fs.openSync(gatewayLogPath, "a");
-    const gatewayChild = spawn("bun", ["run", "src/index.ts"], {
-      cwd: gatewayDir,
-      detached: true,
-      stdio: ["ignore", logFd, logFd],
-      env: { ...process.env, ...dotenvVars }
-    });
-    gatewayChild.unref();
-    fs.closeSync(logFd);
-  } catch (err) {
-    fs.rmSync(INSTALL_DIR, { recursive: true, force: true });
-    throw err;
-  }
-}
-var command = process.argv[2];
-if (command === "hatch") {
-  hatch().catch((err) => {
-    console.error(`Error: ${err.message}`);
-    process.exit(1);
-  });
-} else {
-  console.error("Usage: vellum hatch");
-  process.exit(1);
-}