env-lane 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Bill Toshiaki Stark
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,22 @@
+# env-lane
+
+CLI for workspace-aware dotenv injection and optional development vault helpers.
+
+```bash
+pnpm add -D env-lane
+```
+
+```bash
+env-lane packages
+env-lane files api --build production
+env-lane print api --build production --format json
+env-lane run api --build production -- pnpm start
+env-lane check api --build production --require-override
+env-lane sort env-lane.config.ts api production
+```
+
+The package also re-exports `@env-lane/core` APIs for convenience.
+
+Vault commands are optional and require installing `@env-lane/vault` alongside `env-lane`.
+
+See the full documentation at https://github.com/billstark001/env-lane#readme.

package/dist/cli.js

@@ -0,0 +1,294 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import {
+  checkDotenvSelector,
+  getLogger,
+  listEnvFiles,
+  listWorkspacePackages,
+  loadEnvLaneConfig,
+  redactValue,
+  resolveInjectedEnv,
+  resolveTargetPackage,
+  runWithInjectedEnv,
+  setLogger,
+  sortEnvFile,
+  sortEnvFilesFromConfig
+} from "@env-lane/core";
+import { Command } from "commander";
+import { createConsola } from "consola";
+var consola = createConsola();
+setLogger({
+  log: (msg, ...args) => consola.log(msg, ...args),
+  info: (msg, ...args) => consola.info(msg, ...args),
+  warn: (msg, ...args) => consola.warn(msg, ...args),
+  error: (msg, ...args) => consola.error(msg, ...args),
+  success: (msg, ...args) => consola.success(msg, ...args),
+  debug: (msg, ...args) => consola.debug(msg, ...args),
+  write: (msg) => process.stdout.write(msg)
+});
+var program = new Command();
+program.name("env-lane").description("Workspace-aware dotenv injection and development vault tooling.").version("0.1.0").option("--format <format>", "output format (text, json, dotenv)").option("--json", "use json output format (shorthand for --format json)");
+program.enablePositionalOptions();
+function addCommonOptions(command) {
+  return command.option("-c, --config <file>", "env-lane config file").option("-b, --build <name>", "build selector value").option("--cwd <dir>", "working directory").option("--format <format>", "output format (text, json, dotenv)").option("--json", "use json output format (shorthand for --format json)");
+}
+async function resolveOutputFormat(opts, defaultFormat = "text") {
+  let format;
+  if (opts.json) {
+    format = "json";
+  } else if (opts.format) {
+    format = opts.format;
+  } else {
+    const config = await loadEnvLaneConfig({ configFile: opts.config, cwd: opts.cwd });
+    format = config.output.format ?? defaultFormat;
+  }
+  if (format === "json") {
+    consola.level = 2;
+  }
+  return format;
+}
+async function loadVaultModule() {
+  try {
+    return await import("@env-lane/vault");
+  } catch (error) {
+    if (error && typeof error === "object" && "code" in error && error.code === "ERR_MODULE_NOT_FOUND" && error instanceof Error && error.message.includes("@env-lane/vault")) {
+      throw new Error(
+        "Vault commands require the optional @env-lane/vault package. Install it with: pnpm add -D @env-lane/vault"
+      );
+    }
+    throw error;
+  }
+}
+addCommonOptions(program.command("packages")).description("List discovered workspace packages. Falls back to root in single-package projects.").action(async (opts) => {
+  const allOpts = { ...program.opts(), ...opts };
+  const format = await resolveOutputFormat(allOpts, "text");
+  const packages = await listWorkspacePackages({ cwd: allOpts.cwd, configFile: allOpts.config });
+  const logger = getLogger();
+  if (format === "json") {
+    logger.log(JSON.stringify(packages, null, 2));
+  } else {
+    for (const pkg of packages)
+      logger.log(`${pkg.name ?? "<unnamed>"}	${pkg.relativeDir}	${pkg.aliases.join(",")}`);
+  }
+});
+addCommonOptions(program.command("resolve-target <target>")).description("Resolve a target alias/name/path to a package.").action(async (target, opts) => {
+  const allOpts = { ...program.opts(), ...opts };
+  const format = await resolveOutputFormat(allOpts, "json");
+  const resolved = await resolveTargetPackage(target, {
+    cwd: allOpts.cwd,
+    configFile: allOpts.config
+  });
+  if (format === "json") {
+    getLogger().log(JSON.stringify(resolved, null, 2));
+  } else {
+    getLogger().log(`${resolved.name ?? "<unnamed>"} ${resolved.dir}`);
+  }
+});
+addCommonOptions(program.command("files [target]")).alias("env-files").description("List dotenv files in injection order.").option("--require-override", "fail if selected override file is missing").action(async (target, opts) => {
+  const allOpts = { ...program.opts(), ...opts };
+  const format = await resolveOutputFormat(allOpts, "text");
+  if (target === "all") {
+    const packages = await listWorkspacePackages({ cwd: allOpts.cwd, configFile: allOpts.config });
+    const result = await Promise.all(
+      packages.map(async (pkg) => ({
+        target: pkg,
+        files: await listEnvFiles({
+          cwd: allOpts.cwd,
+          configFile: allOpts.config,
+          target: pkg.relativeDir,
+          build: allOpts.build,
+          requireOverride: allOpts.requireOverride
+        })
+      }))
+    );
+    if (format === "json") {
+      getLogger().log(JSON.stringify(result, null, 2));
+    } else {
+      for (const entry of result) {
+        getLogger().log(`# ${entry.target.name ?? entry.target.relativeDir}`);
+        for (const file of entry.files)
+          getLogger().log(
+            `${file.exists ? "loaded " : "missing"} ${file.kind.padEnd(8)} ${file.relativePath}`
+          );
+      }
+    }
+    return;
+  }
+  const files = await listEnvFiles({
+    cwd: allOpts.cwd,
+    configFile: allOpts.config,
+    target,
+    build: allOpts.build,
+    requireOverride: allOpts.requireOverride
+  });
+  if (format === "json") {
+    getLogger().log(JSON.stringify(files, null, 2));
+  } else {
+    for (const file of files)
+      getLogger().log(
+        `${file.exists ? "loaded " : "missing"} ${file.kind.padEnd(8)} ${file.relativePath}`
+      );
+  }
+});
+addCommonOptions(program.command("print <target>")).alias("env-json").description("Print final injected environment for a target.").option("--show-secrets", "print secret-like values without redaction").option(
+  "--include-shell",
+  "print all shell environment variables, not only dotenv keys and the selector"
+).option("--no-process-env", "do not merge process.env").action(async (target, opts) => {
+  const allOpts = { ...program.opts(), ...opts };
+  const format = await resolveOutputFormat(allOpts, "dotenv");
+  const resolved = await resolveInjectedEnv({
+    cwd: allOpts.cwd,
+    configFile: allOpts.config,
+    target,
+    build: allOpts.build,
+    includeProcessEnv: allOpts.processEnv
+  });
+  const keys = Object.keys(resolved.values).filter(
+    (key) => allOpts.includeShell || resolved.sources[key]?.source !== "process" || resolved.sources[key]?.shellOverride
+  ).sort();
+  if (format === "json") {
+    const payload = Object.fromEntries(
+      keys.map((key) => [
+        key,
+        {
+          value: redactValue(key, resolved.values[key], allOpts.showSecrets),
+          source: resolved.sources[key]
+        }
+      ])
+    );
+    getLogger().log(JSON.stringify(payload, null, 2));
+  } else {
+    for (const key of keys)
+      getLogger().log(`${key}=${redactValue(key, resolved.values[key], allOpts.showSecrets)}`);
+  }
+});
+addCommonOptions(
+  program.command("run <target>").argument("<command...>", "command and arguments to run").allowUnknownOption(true).passThroughOptions()
+).description("Run a command with injected dotenv environment.").option("--run-cwd <target|root|path>", "command working directory", "target").option("--quiet", "suppress run summary").action(async (target, command, opts) => {
+  const allOpts = { ...program.opts(), ...opts };
+  const format = await resolveOutputFormat(allOpts, "text");
+  const code = await runWithInjectedEnv({
+    cwd: allOpts.cwd,
+    configFile: allOpts.config,
+    target,
+    build: allOpts.build,
+    command,
+    runCwd: allOpts.runCwd,
+    quiet: allOpts.quiet || format === "json"
+  });
+  process.exit(code);
+});
+addCommonOptions(program.command("check [target]")).description("Check that the selector key is not stored in dotenv files.").option("--require-override", "fail if selected override file is missing").action(async (target, opts) => {
+  const allOpts = { ...program.opts(), ...opts };
+  const format = await resolveOutputFormat(allOpts, "text");
+  const result = await checkDotenvSelector({
+    cwd: allOpts.cwd,
+    configFile: allOpts.config,
+    target,
+    build: allOpts.build,
+    requireOverride: allOpts.requireOverride
+  });
+  if (format === "json") {
+    getLogger().log(JSON.stringify(result, null, 2));
+    if (!result.ok) process.exit(1);
+    return;
+  }
+  if (!result.ok) {
+    if (result.violations.length) {
+      getLogger().error(
+        `${result.selectorKey} must not be stored in dotenv files:
+${result.violations.map((v) => `  ${v.relativeFile}${v.line ? `:${v.line}` : ""}`).join("\n")}`
+      );
+    }
+    if (result.missingRequired.length) {
+      getLogger().error(
+        `Missing required env file(s):
+${result.missingRequired.map((file) => `  ${file.target}: ${file.relativeFile}`).join("\n")}`
+      );
+    }
+    process.exit(1);
+  }
+  getLogger().success(`[env-lane] OK: ${result.selectorKey} is absent from dotenv files.`);
+});
+var vault = program.command("vault").description("Optional unsafe development vault helpers. Requires @env-lane/vault.");
+addCommonOptions(vault.command("encrypt <config> <keyFile>")).action(
+  async (config, keyFile, opts) => {
+    const allOpts = { ...program.opts(), ...opts };
+    const format = await resolveOutputFormat(allOpts, "json");
+    const { encryptEnvFiles } = await loadVaultModule();
+    const result = await encryptEnvFiles(config, keyFile);
+    if (format === "json") {
+      getLogger().log(JSON.stringify(result, null, 2));
+    } else {
+      getLogger().log(`Encrypted records to ${result.storePath}`);
+      getLogger().log(`  Set: ${result.setRecordsWritten}`);
+      getLogger().log(`  Delete: ${result.deleteRecordsWritten}`);
+      getLogger().log(`  Skipped unchanged: ${result.skippedUnchanged}`);
+    }
+  }
+);
+addCommonOptions(vault.command("plan <config> <keyFile>")).description("Print the vault restore plan without writing files.").action(async (config, keyFile, opts) => {
+  const allOpts = { ...program.opts(), ...opts };
+  const format = await resolveOutputFormat(allOpts, "json");
+  const { buildRestorePlan } = await loadVaultModule();
+  const result = await buildRestorePlan(config, keyFile);
+  if (format === "json") {
+    getLogger().log(JSON.stringify(result, null, 2));
+  } else {
+    getLogger().log(`Restore plan for ${result.storePath}:`);
+    for (const file of result.files) {
+      const changes = file.entries.filter((e) => e.action !== "identical");
+      if (changes.length > 0) {
+        getLogger().log(`# ${file.filePath}`);
+        for (const e of changes) getLogger().log(`  ${e.action.padEnd(10)} ${e.key}`);
+      }
+    }
+    getLogger().log(`Summary: ${result.summary.filesWithChanges} files to change.`);
+  }
+});
+addCommonOptions(vault.command("decrypt <config> <keyFile>")).option("--dry-run", "show planned restore without writing files").option("-y, --yes", "apply restore without interactive confirmation").action(async (config, keyFile, opts) => {
+  const allOpts = { ...program.opts(), ...opts };
+  const format = await resolveOutputFormat(allOpts, "json");
+  const { decryptEnvFiles } = await loadVaultModule();
+  const result = await decryptEnvFiles(config, keyFile, {
+    dryRun: allOpts.dryRun,
+    autoApprove: allOpts.yes
+  });
+  if (format === "json") {
+    getLogger().log(JSON.stringify(result, null, 2));
+  } else {
+    getLogger().log(`Decrypted ${result.filesWritten} files from ${result.storePath}`);
+  }
+});
+addCommonOptions(program.command("sort-file <envFile> <templateFile>")).description("Sort one env file using a template env file.").action(async (envFile, templateFile, opts) => {
+  const allOpts = { ...program.opts(), ...opts };
+  const format = await resolveOutputFormat(allOpts, "json");
+  const result = await sortEnvFile(envFile, templateFile);
+  if (format === "json") {
+    getLogger().log(JSON.stringify(result, null, 2));
+  } else {
+    getLogger().log(`${result.applied ? "Sorted" : "No changes for"} ${envFile}`);
+    if (result.applied) {
+      getLogger().log(`  Moved: ${result.movedCount}`);
+      getLogger().log(`  Inserted commented: ${result.insertedCommentedCount}`);
+    }
+  }
+});
+addCommonOptions(program.command("sort <config> [key] [envSuffix]")).description("Sort env files using an env-lane config sort section.").action(async (config, key = "all", envSuffix = "all", opts) => {
+  const allOpts = { ...program.opts(), ...opts };
+  const format = await resolveOutputFormat(allOpts, "json");
+  const result = await sortEnvFilesFromConfig(config, key, envSuffix);
+  if (format === "json") {
+    getLogger().log(JSON.stringify(result, null, 2));
+  } else {
+    getLogger().log(`Sort applied: ${result.applied}`);
+    for (const r of result.results) {
+      getLogger().log(`${r.applied ? "SORTED " : "SKIPPED"} ${r.filePath}`);
+    }
+  }
+});
+program.parseAsync().catch((error) => {
+  getLogger().error(error instanceof Error ? error.message : String(error));
+  process.exit(1);
+});

package/dist/index.cjs

@@ -0,0 +1,24 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+module.exports = __toCommonJS(index_exports);
+__reExport(index_exports, require("@env-lane/core"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("@env-lane/core")
+});

package/dist/index.d.cts

@@ -0,0 +1 @@
+export * from '@env-lane/core';

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from '@env-lane/core';

package/dist/index.js

@@ -0,0 +1,2 @@
+// src/index.ts
+export * from "@env-lane/core";

package/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "env-lane",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "CLI for env-lane dotenv injection and optional development vault helpers.",
+  "license": "MIT",
+  "author": "billstark001",
+  "homepage": "https://github.com/billstark001/env-lane#readme",
+  "bugs": {
+    "url": "https://github.com/billstark001/env-lane/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/billstark001/env-lane.git",
+    "directory": "packages/cli"
+  },
+  "keywords": [
+    "dotenv",
+    "env",
+    "environment",
+    "cli",
+    "workspace",
+    "pnpm"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "env-lane": "./dist/cli.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "dependencies": {
+    "commander": "^14.0.3",
+    "consola": "^3.4.2",
+    "@env-lane/core": "0.1.0"
+  },
+  "devDependencies": {
+    "@env-lane/vault": "0.1.0"
+  },
+  "peerDependencies": {
+    "@env-lane/vault": "^0.1.0"
+  },
+  "peerDependenciesMeta": {
+    "@env-lane/vault": {
+      "optional": true
+    }
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts --clean && tsup src/cli.ts --format esm --clean false",
+    "dev": "tsx src/cli.ts",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "lint": "biome check ."
+  }
+}