@scira/cli 0.1.1 → 0.1.3

package/dist/cli/commands/init.js

@@ -5,6 +5,7 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 import * as p from "@clack/prompts";
 import { detectEnv } from "../../providers/llm/readiness.js";
+import { ENV_KEY_GUIDES, formatKeyGuide } from "../../config/env-guide.js";
 import { listModels } from "../../providers/llm/models.js";
 import { LLM_PROVIDERS, LLM_PROVIDER_LABELS, defaultModelFor } from "../../providers/llm/registry.js";
 const SCIRA_DIR = join(homedir(), ".scira");
@@ -80,13 +81,14 @@ export async function initCommand() {
         process.exit(0);
     }
     // Step 2: API Keys based on provider
-    p.note("Scira requires API keys to function. Let's set them up.", "API Keys");
+    p.note("Scira needs API keys for your LLM and search providers.\nKeys are saved to ~/.scira/.env (or copy .env.example to <project>/.scira/.env).\nRun scira doctor or scira keys anytime to verify.", "API Keys");
     const envKeys = { ...existingEnv };
     if (llmProvider === "gateway") {
         if (!envKeys.AI_GATEWAY_API_KEY || shouldReconfigure) {
+            p.note(formatKeyGuide("AI_GATEWAY_API_KEY"), "How to get AI_GATEWAY_API_KEY");
             const aiGatewayKey = await p.text({
                 message: envKeys.AI_GATEWAY_API_KEY ? "Enter your Vercel AI Gateway API key (current: *****)" : "Enter your Vercel AI Gateway API key",
-                placeholder: "sk-...",
+                placeholder: ENV_KEY_GUIDES.AI_GATEWAY_API_KEY.placeholder,
                 defaultValue: envKeys.AI_GATEWAY_API_KEY,
                 validate: (value) => {
                     if (!value)
@@ -107,9 +109,10 @@ export async function initCommand() {
     }
     else if (llmProvider === "xai") {
         if (!envKeys.XAI_API_KEY || shouldReconfigure) {
+            p.note(formatKeyGuide("XAI_API_KEY"), "How to get XAI_API_KEY");
             const xaiKey = await p.text({
                 message: envKeys.XAI_API_KEY ? "Enter your xAI API key (current: *****)" : "Enter your xAI API key",
-                placeholder: "sk-...",
+                placeholder: ENV_KEY_GUIDES.XAI_API_KEY.placeholder,
                 defaultValue: envKeys.XAI_API_KEY,
                 validate: (value) => {
                     if (!value)
@@ -128,6 +131,7 @@ export async function initCommand() {
     }
     else if (llmProvider === "workers-ai") {
         if (!envKeys.CLOUDFLARE_ACCOUNT_ID || !envKeys.CLOUDFLARE_API_TOKEN || shouldReconfigure) {
+            p.note(formatKeyGuide("CLOUDFLARE_ACCOUNT_ID"), "How to get CLOUDFLARE_ACCOUNT_ID");
             const accountId = await p.text({
                 message: envKeys.CLOUDFLARE_ACCOUNT_ID ? "Enter your Cloudflare Account ID (current: *****)" : "Enter your Cloudflare Account ID",
                 placeholder: "your-account-id",
@@ -141,9 +145,10 @@ export async function initCommand() {
                 p.cancel("Setup cancelled.");
                 process.exit(0);
             }
+            p.note(formatKeyGuide("CLOUDFLARE_API_TOKEN"), "How to get CLOUDFLARE_API_TOKEN");
             const apiToken = await p.text({
                 message: envKeys.CLOUDFLARE_API_TOKEN ? "Enter your Cloudflare API Token (current: *****)" : "Enter your Cloudflare API Token",
-                placeholder: "your-api-token",
+                placeholder: ENV_KEY_GUIDES.CLOUDFLARE_API_TOKEN.placeholder,
                 defaultValue: envKeys.CLOUDFLARE_API_TOKEN,
                 validate: (value) => {
                     if (!value)
@@ -163,9 +168,10 @@ export async function initCommand() {
     }
     else if (llmProvider === "huggingface") {
         if (!envKeys.HF_API_KEY || shouldReconfigure) {
+            p.note(formatKeyGuide("HF_API_KEY"), "How to get HF_API_KEY");
             const hfKey = await p.text({
                 message: envKeys.HF_API_KEY ? "Enter your HuggingFace API key (current: *****)" : "Enter your HuggingFace API key",
-                placeholder: "hf_...",
+                placeholder: ENV_KEY_GUIDES.HF_API_KEY.placeholder,
                 defaultValue: envKeys.HF_API_KEY,
                 validate: (value) => {
                     if (!value)
@@ -182,7 +188,6 @@ export async function initCommand() {
             p.log.success("HuggingFace API key already set");
         }
     }
-    // Optional search provider keys
     const searchProvider = await p.select({
         message: "Select search provider",
         options: SEARCH_PROVIDERS.map((provider) => ({
@@ -195,41 +200,48 @@ export async function initCommand() {
         p.cancel("Setup cancelled.");
         process.exit(0);
     }
-    if (searchProvider === "exa") {
-        if (!envKeys.EXA_API_KEY || shouldReconfigure) {
-            const exaKey = await p.text({
-                message: envKeys.EXA_API_KEY ? "Enter your Exa API key (optional, current: *****)" : "Enter your Exa API key (optional, press Enter to skip)",
-                placeholder: "exa_...",
-                defaultValue: envKeys.EXA_API_KEY,
-            });
-            if (p.isCancel(exaKey)) {
-                p.cancel("Setup cancelled.");
-                process.exit(0);
-            }
-            if (exaKey)
-                envKeys.EXA_API_KEY = exaKey;
-        }
-        else {
-            p.log.success("Exa API key already set");
+    const searchKeyName = searchProvider === "exa"
+        ? "EXA_API_KEY"
+        : searchProvider === "firecrawl"
+            ? "FIRECRAWL_API_KEY"
+            : "PARALLEL_API_KEY";
+    if (!envKeys[searchKeyName] || shouldReconfigure) {
+        p.note(formatKeyGuide(searchKeyName), `How to get ${searchKeyName}`);
+        const searchKey = await p.text({
+            message: envKeys[searchKeyName]
+                ? `Enter your ${searchProvider} API key (current: *****)`
+                : `Enter your ${searchProvider} API key (required for ${searchProvider} search)`,
+            placeholder: ENV_KEY_GUIDES[searchKeyName].placeholder,
+            defaultValue: envKeys[searchKeyName],
+            validate: (value) => {
+                if (!value?.trim())
+                    return `${searchKeyName} is required when search.provider is ${searchProvider}`;
+            },
+        });
+        if (p.isCancel(searchKey)) {
+            p.cancel("Setup cancelled.");
+            process.exit(0);
         }
+        envKeys[searchKeyName] = searchKey.trim();
     }
-    else if (searchProvider === "firecrawl") {
-        if (!envKeys.FIRECRAWL_API_KEY || shouldReconfigure) {
-            const firecrawlKey = await p.text({
-                message: envKeys.FIRECRAWL_API_KEY ? "Enter your Firecrawl API key (optional, current: *****)" : "Enter your Firecrawl API key (optional, press Enter to skip)",
-                placeholder: "fc-...",
-                defaultValue: envKeys.FIRECRAWL_API_KEY,
-            });
-            if (p.isCancel(firecrawlKey)) {
-                p.cancel("Setup cancelled.");
-                process.exit(0);
-            }
-            if (firecrawlKey)
-                envKeys.FIRECRAWL_API_KEY = firecrawlKey;
-        }
-        else {
-            p.log.success("Firecrawl API key already set");
+    else {
+        p.log.success(`${searchKeyName} already set`);
+    }
+    if (searchProvider !== "firecrawl" && (!envKeys.FIRECRAWL_API_KEY || shouldReconfigure)) {
+        p.note(`${formatKeyGuide("FIRECRAWL_API_KEY")}\n\nOptional but recommended: used as automatic fallback if ${searchProvider} search fails.`, "Firecrawl fallback (optional)");
+        const firecrawlKey = await p.text({
+            message: envKeys.FIRECRAWL_API_KEY
+                ? "Enter your Firecrawl API key for fallback (current: *****, Enter to keep)"
+                : "Enter your Firecrawl API key for fallback (optional, Enter to skip)",
+            placeholder: ENV_KEY_GUIDES.FIRECRAWL_API_KEY.placeholder,
+            defaultValue: envKeys.FIRECRAWL_API_KEY,
+        });
+        if (p.isCancel(firecrawlKey)) {
+            p.cancel("Setup cancelled.");
+            process.exit(0);
         }
+        if (firecrawlKey?.trim())
+            envKeys.FIRECRAWL_API_KEY = firecrawlKey.trim();
     }
     // Write .env file
     const envContent = Object.entries(envKeys)
@@ -368,5 +380,5 @@ export async function initCommand() {
         s2.stop(`Missing: ${missingRequired.map((c) => c.name).join(", ")}`);
         p.note("Some required credentials are missing. Please run `scira init` again.", "Warning");
     }
-    p.outro("Setup complete! Run `scira doctor` to verify your configuration.");
+    p.outro("Setup complete! Run `scira doctor` to verify, or `scira keys` for signup links.");
 }

package/dist/cli/index.js

@@ -7,18 +7,12 @@ if (typeof Bun === "undefined") {
 import { readFileSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
-import { homedir } from "node:os";
 import { fileURLToPath } from "node:url";
 import sade from "sade";
 const { version: pkgVersion } = JSON.parse(readFileSync(join(dirname(fileURLToPath(import.meta.url)), "../../package.json"), "utf8"));
-// Load keys from the global config dir (~/.scira/.env) so they work regardless
-// of where the CLI is invoked from (e.g. after pnpm link / global install).
-try {
-    process.loadEnvFile(join(homedir(), ".scira", ".env"));
-}
-catch {
-    // no ~/.scira/.env present; rely on the ambient environment
-}
+import { loadSciraEnv } from "../config/env-store.js";
+// Shell env wins, then ~/.scira/.env, then <cwd>/.scira/.env (project overrides global).
+loadSciraEnv(process.cwd());
 import { loadConfig } from "../config/load-config.js";
 import { createRun, findRun, listRuns, summarizeRun, verificationReport, getRunPaths } from "../storage/run-store.js";
 import { readJsonl } from "../storage/jsonl.js";
@@ -26,6 +20,7 @@ import { runResearchAgent } from "../agent/research-agent.js";
 import { openShell } from "./shell/shell.js";
 import { openTui, openTuiHome } from "./shell/tui.js";
 import { detectEnv } from "../providers/llm/readiness.js";
+import { envFileSetupInstructions, formatMissingKeysHelp } from "../config/env-guide.js";
 import { requireLlmKeys } from "../providers/llm/registry.js";
 import { listModels } from "../providers/llm/models.js";
 import { listGatewayModels } from "../providers/llm/gateway.js";
@@ -50,9 +45,8 @@ prog
     requireLlmKeys(config);
     const run = await createRun(question, config);
     console.log(`Run: ${run.path}`);
-    if (opts.workspace) {
+    if (opts.workspace)
         console.log(`Workspace: ${opts.workspace}`);
-    }
     console.log("");
     await runResearchAgent(run.path, question, config, opts.workspace);
     console.log(`\nRun complete: ${run.path}`);
@@ -398,17 +392,39 @@ prog
     const blockers = [];
     if (!nodeCheck.ok)
         blockers.push(`upgrade Node to >=${nodeCheck.required}`);
-    if (missingRequired.length > 0)
-        blockers.push(`set ${missingRequired.map((c) => c.name).join(", ")} in ~/.scira/.env`);
+    if (missingRequired.length > 0) {
+        blockers.push(`set ${missingRequired.map((c) => c.name).join(", ")} in ~/.scira/.env or .scira/.env in your project`);
+    }
     console.log("");
     if (blockers.length > 0) {
         console.log(`Action needed: ${blockers.join("; ")} to enable research runs.`);
-        console.log(`  Tip: cp .env.example ~/.scira/.env  then fill in your keys.`);
+        console.log("");
+        const help = formatMissingKeysHelp(checks);
+        if (help)
+            console.log(help);
     }
     else {
         console.log("All required credentials present. Ready to run.");
     }
 });
+prog
+    .command("keys", "show how to get and set API keys")
+    .action(async () => {
+    const config = await loadConfig();
+    const checks = detectEnv(config.search.provider, config.llmProvider);
+    console.log(`LLM provider: ${config.llmProvider}`);
+    console.log(`Search provider: ${config.search.provider}`);
+    console.log("");
+    const help = formatMissingKeysHelp(checks);
+    if (help) {
+        console.log(help);
+    }
+    else {
+        console.log("All required keys for your current config are set.");
+        console.log("");
+        console.log(envFileSetupInstructions());
+    }
+});
 function checkNodeVersion(required) {
     const m = /^v(\d+)/u.exec(process.version);
     const current = m ? Number(m[1]) : 0;

package/dist/config/env-guide.js

@@ -0,0 +1,151 @@
+export const ENV_KEY_GUIDES = {
+    AI_GATEWAY_API_KEY: {
+        name: "AI_GATEWAY_API_KEY",
+        label: "Vercel AI Gateway",
+        signupUrl: "https://vercel.com/docs/ai-gateway",
+        docsUrl: "https://vercel.com/docs/ai-gateway/authentication",
+        placeholder: "sk-...",
+        steps: [
+            "Sign in at vercel.com (free tier works).",
+            "Open your team dashboard → AI Gateway → API Keys.",
+            "Create a key and paste it here (starts with vc_)."
+        ]
+    },
+    XAI_API_KEY: {
+        name: "XAI_API_KEY",
+        label: "xAI (Grok)",
+        signupUrl: "https://console.x.ai/",
+        docsUrl: "https://docs.x.ai/docs/overview",
+        placeholder: "xai-...",
+        steps: [
+            "Create an account at console.x.ai.",
+            "Open API Keys in the sidebar.",
+            "Create a key and paste it here."
+        ]
+    },
+    CLOUDFLARE_ACCOUNT_ID: {
+        name: "CLOUDFLARE_ACCOUNT_ID",
+        label: "Cloudflare account ID",
+        signupUrl: "https://dash.cloudflare.com/",
+        docsUrl: "https://developers.cloudflare.com/workers-ai/get-started/rest-api/",
+        placeholder: "32-character account id",
+        steps: [
+            "Sign in at dash.cloudflare.com.",
+            "Copy Account ID from the Workers & Pages overview (right-hand sidebar)."
+        ]
+    },
+    CLOUDFLARE_API_TOKEN: {
+        name: "CLOUDFLARE_API_TOKEN",
+        label: "Cloudflare API token",
+        signupUrl: "https://dash.cloudflare.com/profile/api-tokens",
+        docsUrl: "https://developers.cloudflare.com/workers-ai/get-started/rest-api/",
+        placeholder: "cloudflare api token",
+        steps: [
+            "Go to My Profile → API Tokens → Create Token.",
+            "Use the \"Edit Cloudflare Workers AI\" template (or Workers AI Read).",
+            "Create the token and paste it here."
+        ]
+    },
+    HF_API_KEY: {
+        name: "HF_API_KEY",
+        label: "Hugging Face Inference",
+        signupUrl: "https://huggingface.co/settings/tokens",
+        docsUrl: "https://huggingface.co/docs/inference-providers/index",
+        placeholder: "hf_...",
+        steps: [
+            "Create a Hugging Face account.",
+            "Open Settings → Access Tokens → Create new token.",
+            "Choose a token with Inference permissions and paste it here."
+        ]
+    },
+    EXA_API_KEY: {
+        name: "EXA_API_KEY",
+        label: "Exa search",
+        signupUrl: "https://dashboard.exa.ai/api-keys",
+        docsUrl: "https://docs.exa.ai/reference/getting-started",
+        placeholder: "exa_...",
+        steps: [
+            "Sign up at dashboard.exa.ai.",
+            "Open API Keys and create a key.",
+            "Paste the key here (starts with exa_)."
+        ]
+    },
+    FIRECRAWL_API_KEY: {
+        name: "FIRECRAWL_API_KEY",
+        label: "Firecrawl search + scrape",
+        signupUrl: "https://www.firecrawl.dev/app/api-keys",
+        docsUrl: "https://docs.firecrawl.dev/introduction",
+        placeholder: "fc-...",
+        steps: [
+            "Sign up at firecrawl.dev.",
+            "Open the dashboard → API Keys.",
+            "Create a key and paste it here."
+        ]
+    },
+    PARALLEL_API_KEY: {
+        name: "PARALLEL_API_KEY",
+        label: "Parallel search",
+        signupUrl: "https://platform.parallel.ai/",
+        docsUrl: "https://docs.parallel.ai/search/search-quickstart",
+        placeholder: "parallel api key",
+        steps: [
+            "Sign up at platform.parallel.ai.",
+            "Open API Keys in the dashboard.",
+            "Create a key and paste it here."
+        ]
+    }
+};
+export function envFileSetupInstructions() {
+    return [
+        "Where to save keys (pick one):",
+        "  ~/.scira/.env          global — works from any directory",
+        "  <project>/.scira/.env  project — overrides global when run from that folder",
+        "",
+        "Quick setup:",
+        "  scira init             interactive wizard (saves to ~/.scira/.env)",
+        "  cp .env.example ~/.scira/.env   then edit the file",
+        "  scira doctor           verify keys are detected"
+    ].join("\n");
+}
+export function formatKeyGuide(name) {
+    const guide = ENV_KEY_GUIDES[name];
+    const lines = [
+        `${guide.label} (${guide.name})`,
+        `Get a key: ${guide.signupUrl}`,
+        ...guide.steps.map((step, i) => `  ${i + 1}. ${step}`)
+    ];
+    if (guide.docsUrl)
+        lines.push(`Docs: ${guide.docsUrl}`);
+    return lines.join("\n");
+}
+export function isManagedEnvKeyName(name) {
+    return name in ENV_KEY_GUIDES;
+}
+export function formatMissingKeysHelp(checks) {
+    const missing = checks.filter((c) => c.required && !c.present);
+    if (missing.length === 0)
+        return "";
+    const blocks = ["Missing required keys:", ""];
+    for (const check of missing) {
+        if (!isManagedEnvKeyName(check.name)) {
+            blocks.push(`${check.name} — ${check.purpose}`);
+            continue;
+        }
+        blocks.push(formatKeyGuide(check.name));
+        blocks.push("");
+    }
+    blocks.push(envFileSetupInstructions());
+    return blocks.join("\n");
+}
+export function formatKeysStatus(checks) {
+    const lines = checks.map((c) => {
+        const status = c.present ? "set    " : "missing";
+        const tag = c.required ? " (required)" : " (optional)";
+        let line = `${status} ${c.name}${tag}  — ${c.purpose}`;
+        if (!c.present && isManagedEnvKeyName(c.name)) {
+            line += `\n         ${ENV_KEY_GUIDES[c.name].signupUrl}`;
+        }
+        return line;
+    });
+    return `${lines.join("\n")}\n\n${envFileSetupInstructions()}`;
+}

package/dist/config/env-guide.test.js

@@ -0,0 +1,18 @@
+import { describe, expect, it } from "vitest";
+import { formatKeyGuide, formatMissingKeysHelp } from "./env-guide.js";
+describe("env-guide", () => {
+    it("includes signup URL and steps for a known key", () => {
+        const text = formatKeyGuide("EXA_API_KEY");
+        expect(text).toContain("EXA_API_KEY");
+        expect(text).toContain("dashboard.exa.ai");
+        expect(text).toContain("1.");
+    });
+    it("builds missing-key help from env checks", () => {
+        const help = formatMissingKeysHelp([
+            { name: "EXA_API_KEY", present: false, purpose: "exa web search", required: true }
+        ]);
+        expect(help).toContain("Missing required keys");
+        expect(help).toContain("~/.scira/.env");
+        expect(help).toContain("scira init");
+    });
+});

package/dist/config/env-store.js

@@ -1,4 +1,5 @@
 import process from "node:process";
+import { readFileSync } from "node:fs";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
@@ -17,6 +18,58 @@ export function isManagedEnvKey(name) {
 }
 /** Path to the global env file that the CLI loads on startup. */
 export const globalEnvPath = join(homedir(), ".scira", ".env");
+/** Per-project env file: `<projectRoot>/.scira/.env` (overrides global keys). */
+export function projectEnvPath(projectRoot = process.cwd()) {
+    return join(projectRoot, ".scira", ".env");
+}
+/** Parse simple KEY=VALUE lines from a dotenv file. */
+export function parseEnvFile(content) {
+    const out = [];
+    for (const rawLine of content.split("\n")) {
+        const line = rawLine.trim();
+        if (!line || line.startsWith("#"))
+            continue;
+        const normalized = line.replace(/^export\s+/u, "");
+        const eq = normalized.indexOf("=");
+        if (eq <= 0)
+            continue;
+        const key = normalized.slice(0, eq).trim();
+        if (!key)
+            continue;
+        let value = normalized.slice(eq + 1).trim();
+        if ((value.startsWith("\"") && value.endsWith("\""))
+            || (value.startsWith("'") && value.endsWith("'"))) {
+            value = value.slice(1, -1);
+        }
+        out.push([key, value]);
+    }
+    return out;
+}
+function applyEnvFile(path, opts) {
+    let content;
+    try {
+        content = readFileSync(path, "utf8");
+    }
+    catch {
+        return;
+    }
+    for (const [key, value] of parseEnvFile(content)) {
+        if (opts.skipKeys.has(key))
+            continue;
+        if (!opts.overrideExisting && process.env[key] !== undefined)
+            continue;
+        process.env[key] = value;
+    }
+}
+/**
+ * Load API keys for the current process.
+ * Precedence (highest first): shell env, project `.scira/.env`, `~/.scira/.env`.
+ */
+export function loadSciraEnv(projectRoot = process.cwd()) {
+    const shellKeys = new Set(Object.keys(process.env));
+    applyEnvFile(globalEnvPath, { skipKeys: shellKeys, overrideExisting: false });
+    applyEnvFile(projectEnvPath(projectRoot), { skipKeys: shellKeys, overrideExisting: true });
+}
 /**
  * Persist an environment key to ~/.scira/.env and apply it to the current
  * process so it takes effect immediately without a restart.

package/dist/config/env-store.test.js

@@ -0,0 +1,60 @@
+import { describe, expect, it } from "vitest";
+import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { loadSciraEnv, parseEnvFile, projectEnvPath } from "./env-store.js";
+describe("parseEnvFile", () => {
+    it("parses comments, export prefix, and quoted values", () => {
+        const entries = parseEnvFile(`
+      # comment
+      export EXA_API_KEY=global
+      FIRECRAWL_API_KEY="quoted"
+      PARALLEL_API_KEY='single'
+    `);
+        expect(entries).toEqual([
+            ["EXA_API_KEY", "global"],
+            ["FIRECRAWL_API_KEY", "quoted"],
+            ["PARALLEL_API_KEY", "single"]
+        ]);
+    });
+});
+describe("loadSciraEnv", () => {
+    it("loads project .scira/.env over global values", () => {
+        const projectRoot = mkdtempSync(join(tmpdir(), "scira-env-"));
+        const projectEnv = projectEnvPath(projectRoot);
+        mkdirSync(join(projectRoot, ".scira"), { recursive: true });
+        writeFileSync(projectEnv, "EXA_API_KEY=from-project\n");
+        const shellValue = process.env.EXA_API_KEY;
+        delete process.env.EXA_API_KEY;
+        process.env.SCIRA_TEST_GLOBAL_ENV = "1";
+        process.env.EXA_API_KEY = "from-shell";
+        try {
+            loadSciraEnv(projectRoot);
+            expect(process.env.EXA_API_KEY).toBe("from-shell");
+        }
+        finally {
+            delete process.env.SCIRA_TEST_GLOBAL_ENV;
+            if (shellValue === undefined)
+                delete process.env.EXA_API_KEY;
+            else
+                process.env.EXA_API_KEY = shellValue;
+        }
+    });
+    it("applies project keys when not set in shell", () => {
+        const projectRoot = mkdtempSync(join(tmpdir(), "scira-env-"));
+        mkdirSync(join(projectRoot, ".scira"), { recursive: true });
+        writeFileSync(projectEnvPath(projectRoot), "EXA_API_KEY=from-project\n");
+        const shellValue = process.env.EXA_API_KEY;
+        delete process.env.EXA_API_KEY;
+        try {
+            loadSciraEnv(projectRoot);
+            expect(process.env.EXA_API_KEY).toBe("from-project");
+        }
+        finally {
+            if (shellValue === undefined)
+                delete process.env.EXA_API_KEY;
+            else
+                process.env.EXA_API_KEY = shellValue;
+        }
+    });
+});