clawchef 0.1.4 → 0.1.5

package/README.md

@@ -8,6 +8,7 @@ Recipe-driven OpenClaw environment orchestrator.
 - Accepts recipe input from local file/dir/archive and HTTP URL/archive.
 - Resolves `${var}` parameters from `--var`, environment, and defaults.
 - Auto-loads environment variables from `.env` in the current working directory.
+- Supports loading env vars from a custom `.env` path/URL via `--env-file`.
 - Requires secrets to be injected via `--var` / `CLAWCHEF_VAR_*` (no inline secrets in recipe).
 - Prepares OpenClaw version (install or reuse).
 - When installed OpenClaw version mismatches recipe version, prompts: ignore / abort / force reinstall (silent mode auto-picks force reinstall).
@@ -39,6 +40,13 @@ Run recipe from URL:
 clawchef cook https://example.com/recipes/sample.yaml --provider remote
 ```
 
+Run with custom env file (local path or HTTP URL):
+
+```bash
+clawchef cook recipes/sample.yaml --env-file ./.env.staging
+clawchef cook recipes/sample.yaml --env-file https://example.com/envs/staging.env
+```
+
 Run recipe from GitHub repository root (`recipe.yaml` at repo root):
 
 ```bash
@@ -190,6 +198,7 @@ await scaffold("./my-recipe-project", {
 - `plugins`: plugin npm specs to preinstall for this run (`string[]`)
 - `provider`: `command | remote | mock`
 - `remote`: remote provider config (same fields as CLI remote flags)
+- `envFile`: custom env file path/URL; when set, default cwd `.env` loading is skipped
 - `dryRun`, `allowMissing`, `verbose`
 - `silent` (default: `true` in Node API)
 - `loadDotEnvFromCwd` (default: `true`)
@@ -212,6 +221,7 @@ Notes:
 If `params.<key>.required: true` and no value is found, run fails.
 
 If `.env` exists in the directory where `clawchef` is executed, it is loaded before recipe parsing.
+If `--env-file` (or Node API `envFile`) is provided, only that env source is loaded.
 
 ## Recipe reference formats
 

package/dist/api.d.ts

@@ -9,6 +9,7 @@ export interface CookOptions {
     silent?: boolean;
     provider?: OpenClawProvider;
     remote?: Partial<OpenClawRemoteConfig>;
+    envFile?: string;
     loadDotEnvFromCwd?: boolean;
 }
 export declare function cook(recipeRef: string, options?: CookOptions): Promise<void>;

package/dist/api.js

@@ -1,6 +1,6 @@
 import YAML from "js-yaml";
 import { ClawChefError } from "./errors.js";
-import { importDotEnvFromCwd } from "./env.js";
+import { importDotEnvFromCwd, importDotEnvFromRef } from "./env.js";
 import { Logger } from "./logger.js";
 import { runRecipe } from "./orchestrator.js";
 import { loadRecipe, loadRecipeText } from "./recipe.js";
@@ -21,7 +21,10 @@ function normalizeCookOptions(options) {
     };
 }
 export async function cook(recipeRef, options = {}) {
-    if (options.loadDotEnvFromCwd ?? true) {
+    if (options.envFile) {
+        await importDotEnvFromRef(options.envFile);
+    }
+    else if (options.loadDotEnvFromCwd ?? true) {
         importDotEnvFromCwd();
     }
     const runOptions = normalizeCookOptions(options);

package/dist/cli.js

@@ -1,5 +1,6 @@
 import { Command } from "commander";
 import { ClawChefError } from "./errors.js";
+import { importDotEnvFromCwd, importDotEnvFromRef } from "./env.js";
 import { Logger } from "./logger.js";
 import { runRecipe } from "./orchestrator.js";
 import { loadRecipe, loadRecipeText } from "./recipe.js";
@@ -78,6 +79,7 @@ export function buildCli() {
         .option("--verbose", "Verbose logging", false)
         .option("-s, --silent", "Skip reset confirmation prompt", false)
         .option("--keep-openclaw-state", "Preserve existing OpenClaw state (skip factory reset)", false)
+        .option("--env-file <path-or-url>", "Load env vars from local file or HTTP URL")
         .option("--provider <provider>", "Execution provider: command | remote | mock")
         .option("--plugin <npm-spec>", "Preinstall plugin package (repeatable)", (v, p) => p.concat([v]), [])
         .option("--remote-base-url <url>", "Remote OpenClaw API base URL")
@@ -87,6 +89,12 @@ export function buildCli() {
         .option("--remote-timeout-ms <ms>", "Remote operation timeout in milliseconds")
         .option("--remote-operation-path <path>", "Remote operation endpoint path")
         .action(async (recipeRef, opts) => {
+        if (opts.envFile) {
+            await importDotEnvFromRef(String(opts.envFile));
+        }
+        else {
+            importDotEnvFromCwd();
+        }
         const provider = parseProvider(opts.provider ?? readEnv("CLAWCHEF_PROVIDER") ?? "command");
         const options = {
             vars: parseVarFlags(opts.var),

package/dist/env.d.ts

@@ -1 +1,2 @@
 export declare function importDotEnvFromCwd(): void;
+export declare function importDotEnvFromRef(ref: string): Promise<void>;

package/dist/env.js

@@ -1,6 +1,7 @@
 import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
 import path from "node:path";
-import { config as loadDotenv } from "dotenv";
+import { config as loadDotenv, parse as parseDotenv } from "dotenv";
 import { ClawChefError } from "./errors.js";
 export function importDotEnvFromCwd() {
     const envPath = path.resolve(process.cwd(), ".env");
@@ -12,3 +13,51 @@ export function importDotEnvFromCwd() {
         throw new ClawChefError(`Failed to load .env from current directory: ${result.error.message}`);
     }
 }
+function isHttpUrl(value) {
+    try {
+        const url = new URL(value);
+        return url.protocol === "http:" || url.protocol === "https:";
+    }
+    catch {
+        return false;
+    }
+}
+function applyEnv(entries) {
+    for (const [key, value] of Object.entries(entries)) {
+        if (process.env[key] === undefined) {
+            process.env[key] = value;
+        }
+    }
+}
+export async function importDotEnvFromRef(ref) {
+    const trimmed = ref.trim();
+    if (!trimmed) {
+        throw new ClawChefError("--env-file cannot be empty");
+    }
+    if (isHttpUrl(trimmed)) {
+        let response;
+        try {
+            response = await fetch(trimmed);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            throw new ClawChefError(`Failed to fetch env file URL ${trimmed}: ${message}`);
+        }
+        if (!response.ok) {
+            throw new ClawChefError(`Failed to fetch env file URL ${trimmed}: HTTP ${response.status}`);
+        }
+        const content = await response.text();
+        applyEnv(parseDotenv(content));
+        return;
+    }
+    const envPath = path.resolve(trimmed);
+    let content;
+    try {
+        content = await readFile(envPath, "utf8");
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new ClawChefError(`Failed to load env file ${envPath}: ${message}`);
+    }
+    applyEnv(parseDotenv(content));
+}

package/dist/index.js

@@ -1,9 +1,7 @@
 #!/usr/bin/env node
 import { buildCli } from "./cli.js";
-import { importDotEnvFromCwd } from "./env.js";
 import { ClawChefError } from "./errors.js";
 async function main() {
-    importDotEnvFromCwd();
     const program = buildCli();
     await program.parseAsync(process.argv);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clawchef",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "Recipe-driven OpenClaw environment orchestrator",
   "homepage": "https://renorzr.github.io/clawchef",
   "repository": {

package/src/api.ts

@@ -1,6 +1,6 @@
 import YAML from "js-yaml";
 import { ClawChefError } from "./errors.js";
-import { importDotEnvFromCwd } from "./env.js";
+import { importDotEnvFromCwd, importDotEnvFromRef } from "./env.js";
 import { Logger } from "./logger.js";
 import { runRecipe } from "./orchestrator.js";
 import { loadRecipe, loadRecipeText } from "./recipe.js";
@@ -18,6 +18,7 @@ export interface CookOptions {
   silent?: boolean;
   provider?: OpenClawProvider;
   remote?: Partial<OpenClawRemoteConfig>;
+  envFile?: string;
   loadDotEnvFromCwd?: boolean;
 }
 
@@ -37,7 +38,9 @@ function normalizeCookOptions(options: CookOptions): RunOptions {
 }
 
 export async function cook(recipeRef: string, options: CookOptions = {}): Promise<void> {
-  if (options.loadDotEnvFromCwd ?? true) {
+  if (options.envFile) {
+    await importDotEnvFromRef(options.envFile);
+  } else if (options.loadDotEnvFromCwd ?? true) {
     importDotEnvFromCwd();
   }
 

package/src/cli.ts

@@ -1,5 +1,6 @@
 import { Command } from "commander";
 import { ClawChefError } from "./errors.js";
+import { importDotEnvFromCwd, importDotEnvFromRef } from "./env.js";
 import { Logger } from "./logger.js";
 import { runRecipe } from "./orchestrator.js";
 import { loadRecipe, loadRecipeText } from "./recipe.js";
@@ -88,6 +89,7 @@ export function buildCli(): Command {
     .option("--verbose", "Verbose logging", false)
     .option("-s, --silent", "Skip reset confirmation prompt", false)
     .option("--keep-openclaw-state", "Preserve existing OpenClaw state (skip factory reset)", false)
+    .option("--env-file <path-or-url>", "Load env vars from local file or HTTP URL")
     .option("--provider <provider>", "Execution provider: command | remote | mock")
     .option("--plugin <npm-spec>", "Preinstall plugin package (repeatable)", (v, p: string[]) => p.concat([v]), [])
     .option("--remote-base-url <url>", "Remote OpenClaw API base URL")
@@ -97,6 +99,12 @@ export function buildCli(): Command {
     .option("--remote-timeout-ms <ms>", "Remote operation timeout in milliseconds")
     .option("--remote-operation-path <path>", "Remote operation endpoint path")
     .action(async (recipeRef: string, opts) => {
+      if (opts.envFile) {
+        await importDotEnvFromRef(String(opts.envFile));
+      } else {
+        importDotEnvFromCwd();
+      }
+
       const provider = parseProvider(opts.provider ?? readEnv("CLAWCHEF_PROVIDER") ?? "command");
       const options: RunOptions = {
         vars: parseVarFlags(opts.var),

package/src/env.ts

@@ -1,6 +1,7 @@
 import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
 import path from "node:path";
-import { config as loadDotenv } from "dotenv";
+import { config as loadDotenv, parse as parseDotenv } from "dotenv";
 import { ClawChefError } from "./errors.js";
 
 export function importDotEnvFromCwd(): void {
@@ -14,3 +15,53 @@ export function importDotEnvFromCwd(): void {
     throw new ClawChefError(`Failed to load .env from current directory: ${result.error.message}`);
   }
 }
+
+function isHttpUrl(value: string): boolean {
+  try {
+    const url = new URL(value);
+    return url.protocol === "http:" || url.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+
+function applyEnv(entries: Record<string, string>): void {
+  for (const [key, value] of Object.entries(entries)) {
+    if (process.env[key] === undefined) {
+      process.env[key] = value;
+    }
+  }
+}
+
+export async function importDotEnvFromRef(ref: string): Promise<void> {
+  const trimmed = ref.trim();
+  if (!trimmed) {
+    throw new ClawChefError("--env-file cannot be empty");
+  }
+
+  if (isHttpUrl(trimmed)) {
+    let response: Response;
+    try {
+      response = await fetch(trimmed);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      throw new ClawChefError(`Failed to fetch env file URL ${trimmed}: ${message}`);
+    }
+    if (!response.ok) {
+      throw new ClawChefError(`Failed to fetch env file URL ${trimmed}: HTTP ${response.status}`);
+    }
+    const content = await response.text();
+    applyEnv(parseDotenv(content));
+    return;
+  }
+
+  const envPath = path.resolve(trimmed);
+  let content: string;
+  try {
+    content = await readFile(envPath, "utf8");
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new ClawChefError(`Failed to load env file ${envPath}: ${message}`);
+  }
+  applyEnv(parseDotenv(content));
+}

package/src/index.ts

@@ -1,10 +1,8 @@
 #!/usr/bin/env node
 import { buildCli } from "./cli.js";
-import { importDotEnvFromCwd } from "./env.js";
 import { ClawChefError } from "./errors.js";
 
 async function main(): Promise<void> {
-  importDotEnvFromCwd();
   const program = buildCli();
   await program.parseAsync(process.argv);
 }