@zenera/cli 1.1.36 → 1.1.37

package/dist/sandbox.js

@@ -1,202 +1,12 @@
-import { DEFAULT_SANDBOX_IMAGE, GATEWAY_URL_ENV, SANDBOX_GROUP, SandboxPool, } from '@zenera/neo';
-import { mkdirSync } from 'node:fs';
-import { basename, join } from 'node:path';
-import { resolveBuild } from "./image.js";
-import { credentials } from "./keys.js";
 import { assertLocks, ensurePodmanReady } from "./podman.js";
-import { warn } from "./term.js";
-// ---------------------------------------------------------------------------
-// The sandbox, as this CLI wires it
-//
-// The library takes resolved values; the config states names and numbers. This
-// is the layer between the two, and it owns the two decisions the library has
-// no business making: which host variables are worth forwarding, and where the
-// container's home directory lives.
-//
-// It lives in the session directory, which is the whole point. A session is
-// already a self-contained thing — copy the directory and its conversation,
-// memory and blobs travel with it — and a `pip install --user` that vanished
-// on close would be the only part of a session that did not. So `$HOME` is a
-// bind mount into `.data/sandbox/home`, and what the agent installs for itself
-// is still there when the session is opened again. Everything *outside* the
-// mounts is throwaway, which is what keeps a stale container from becoming a
-// second, invisible configuration.
-// ---------------------------------------------------------------------------
-/** Where the persistent home lives, inside the container. */
-const HOME = '/home/agent';
-/** Where a credential *file* is mounted, inside the container. */
-const KEY_MOUNT = '/run/zenera/keys';
-/**
- * The credentials the run is using, in the form a container takes.
- *
- * Two shapes, two mechanisms. A secret is forwarded by *name* — podman reads
- * the value from its own environment, so nothing is written into an argv that
- * `ps` will show. A service-account file has to be present as a file, so the
- * one file is bind-mounted read-only and the variable is rewritten to where it
- * landed; mounting the directory it came from would drag in whatever else the
- * user keeps beside it.
- *
- * This is the part of the design that gives something away, and it should be
- * said plainly: the sandbox runs code the model wrote, and a key it can read
- * is a key it can send. `keys: false`, or `network: none`, is the answer for a
- * project where that is not an acceptable trade.
- */
-function forwarded() {
-    const secrets = [];
-    const env = {};
-    const mounts = [];
-    for (const cred of credentials()) {
-        if (cred.holds === 'file') {
-            const at = `${KEY_MOUNT}/${basename(cred.value)}`;
-            mounts.push({ host: cred.value, at, readOnly: true });
-            env[cred.env] = at;
-            continue;
-        }
-        secrets.push(cred.env);
-    }
-    // Not secrets, and useless without one: a service account says which
-    // project it belongs to but never which region to call, and a gateway key
-    // says nothing of where the gateway is.
-    for (const name of ['GOOGLE_CLOUD_PROJECT', 'GOOGLE_CLOUD_LOCATION', GATEWAY_URL_ENV]) {
-        const value = process.env[name];
-        if (value) {
-            env[name] = value;
-        }
-    }
-    return { secrets, env, mounts };
-}
-export function buildSandbox(opts) {
-    // An explicit --image is an answer, so there is nothing left to build.
-    const build = opts.image ? undefined : resolveBuild(opts.root, opts.config.sandbox);
-    const base = {
-        ...(opts.config.sandbox ?? {}),
-        ...((opts.image ?? build?.tag) ? { image: opts.image ?? build?.tag } : {}),
-        ...(opts.keys === false ? { keys: false } : {}),
-        ...(opts.persist === false ? { persist: false } : {}),
-    };
-    const home = join(opts.session.data, 'sandbox', 'home');
-    const mounts = [{ host: home, at: HOME }, ...(opts.mounts ?? [])];
-    const keys = base.keys === false ? undefined : forwarded();
-    if (keys) {
-        mounts.push(...keys.mounts);
-    }
-    // Skills and assets are mounted read-only, and a python script run from a
-    // read-only directory fails on writing its own `__pycache__` — a confusing
-    // error about a file nobody asked for.
-    // `ZENERA_AGENT` tells a `zen` run by `run_command` that no person is there.
-    const extra = { HOME, PYTHONDONTWRITEBYTECODE: '1', ZENERA_AGENT: '1', ...(keys?.env ?? {}) };
-    const spec = toSpec(base, extra, secretsOf(keys?.secrets, opts.env));
-    const agents = {};
-    for (const agent of opts.config.agents) {
-        if (agent.sandbox) {
-            const merged = merge(base, agent.sandbox);
-            if (opts.persist === false) {
-                merged.persist = false;
-            }
-            // An agent that opts out gets neither the variables nor the mount,
-            // but the mount is on the pool and cannot be taken back per agent —
-            // so the variable is what actually decides, and without it the file
-            // sitting there is not a credential anything will look for.
-            const own = merged.keys === false ? undefined : keys;
-            agents[agent.name] = toSpec(merged, { HOME, PYTHONDONTWRITEBYTECODE: '1', ZENERA_AGENT: '1', ...(own?.env ?? {}) }, own && secretsOf(own.secrets, opts.env));
-        }
-    }
-    const pool = new SandboxPool({
-        ...spec,
-        agents,
-        root: opts.workspace,
-        key: opts.session.id,
-        readOnly: opts.readOnly,
-        mounts,
-    });
-    return { pool, spec, image: spec.image ?? DEFAULT_SANDBOX_IMAGE, build, home, mounts };
-}
-/**
- * An agent's overrides on the project's block. `image` and `build` answer the
- * same question, so naming either one drops the other: a plain spread would
- * leave an agent's `image` sitting next to the project's `build`, and the
- * schema forbids exactly that combination when it is written down.
- */
-function merge(base, agent) {
-    const merged = { ...base, ...agent };
-    if (agent.image !== undefined) {
-        delete merged.build;
-    }
-    if (agent.build !== undefined) {
-        delete merged.image;
-    }
-    return merged;
-}
-/**
- * The two sources of forwarded names, as one list: the credentials the keyring
- * selected, and whatever the project's `.env` declares. Deduped, because the
- * same variable named twice is the same `--env` twice.
- *
- * `undefined` in means keys are withheld, and the file goes with them.
- */
-function secretsOf(secrets, env) {
-    if (!secrets) {
-        return undefined;
-    }
-    return [...new Set([...secrets, ...(env ?? [])])];
-}
-/**
- * Config names a variable; this reads it. A name that is not set on this host
- * is simply not forwarded — an empty string in the container is a different
- * thing from an absent one, and tools test for absence.
- *
- * A name that has already been answered with a value drops off the forwarded
- * list: `--env NAME=value` and `--env NAME` are the same variable twice, and
- * the one that carries a value is the one that was resolved on purpose. That
- * matters for `GOOGLE_APPLICATION_CREDENTIALS`, which is rewritten here to
- * where the key file was mounted — a `.env` naming it must not put the host's
- * path back, since that path does not exist inside the container.
- */
-function toSpec(config, extra, secrets) {
-    const env = { ...extra };
-    for (const name of config.env ?? []) {
-        const value = process.env[name];
-        if (value !== undefined && value !== '') {
-            env[name] = value;
-        }
-    }
-    return {
-        image: config.image,
-        cpus: config.cpus,
-        memory: config.memory,
-        network: config.network,
-        workdir: config.workdir,
-        timeout: config.timeout,
-        hardening: config.hardening,
-        user: config.user,
-        persist: config.persist,
-        env,
-        secrets: secrets?.filter((name) => !(name in env)),
-    };
-}
-/**
- * Whether anything in this project can reach a shell.
- *
- * Read off the *resolved* tool lists rather than off the config's selectors,
- * because `sandbox:*`, `*` and a bare name all mean the same thing by the time
- * the loader is done, and only one of those three is greppable.
- */
-export function usesSandbox(project) {
-    return project.agents.some((a) => a.tools.some((t) => t.group === SANDBOX_GROUP));
-}
 /**
  * Images this process has already settled. A batch opens the same project
  * dozens of times at once, and without this each one shells out to podman and
  * the concurrent copies race each other to pull the very same image.
  */
 const READY = new Set();
-/**
- * Asked before the first turn rather than at the first tool call, so a missing
- * container engine costs nothing instead of costing a round trip and half a
- * plan. A project that never shells out never gets here at all.
- */
+/** The engine's preflight on a terminal: podman is offered for install and started if needed. */
 export async function preflight(setup, yes) {
-    mkdirSync(setup.home, { recursive: true });
     if (READY.has(setup.image)) {
         return;
     }
@@ -211,13 +21,4 @@ export async function preflight(setup, yes) {
     await assertLocks(1, { reuses: setup.pool.for().name });
     READY.add(setup.image);
 }
-/** Best-effort teardown: losing a container must never lose a run. */
-export async function teardown(pool) {
-    try {
-        await pool.dispose();
-    }
-    catch (err) {
-        warn(`could not clean up the sandbox: ${err instanceof Error ? err.message : String(err)}`);
-    }
-}
 //# sourceMappingURL=sandbox.js.map

package/dist/term.d.ts

@@ -1,25 +1,4 @@
-export declare const EXIT: {
-    readonly ok: 0;
-    readonly failed: 1;
-    readonly usage: 2;
-    readonly invalid: 3;
-    readonly credentials: 4;
-    readonly sandbox: 5;
-};
-export type ExitCode = (typeof EXIT)[keyof typeof EXIT];
-/**
- * An error that already knows what it means. Anything else reaching the top is
- * a bug and exits `failed`, which is the distinction a script needs: a wrong
- * invocation and a wrong answer are not the same failure.
- */
-export declare class CliError extends Error {
-    readonly code: ExitCode;
-    readonly hint?: string;
-    constructor(message: string, code?: ExitCode, hint?: string);
-}
-export declare const usageError: (m: string, hint?: string) => CliError;
-export declare const invalidError: (m: string, hint?: string) => CliError;
-export declare const credentialError: (m: string, hint?: string) => CliError;
+export { EngineError as CliError, credentialError, EXIT, invalidError, usageError, type ExitCode, } from '@zenera/engine';
 export type Appearance = 'dark' | 'light';
 /** One grey per background. The only 256-colour indices in the CLI. */
 export declare const CHROME: Record<Appearance, number>;

package/dist/term.js

@@ -11,32 +11,9 @@ import { styleText } from 'node:util';
 // `styleText` no-ops when the stream is not a tty and honours NO_COLOR itself,
 // so there is no flag to thread through and no piped output to garble.
 // ---------------------------------------------------------------------------
-export const EXIT = {
-    ok: 0,
-    failed: 1,
-    usage: 2,
-    invalid: 3,
-    credentials: 4,
-    sandbox: 5,
-};
-/**
- * An error that already knows what it means. Anything else reaching the top is
- * a bug and exits `failed`, which is the distinction a script needs: a wrong
- * invocation and a wrong answer are not the same failure.
- */
-export class CliError extends Error {
-    code;
-    hint;
-    constructor(message, code = EXIT.failed, hint) {
-        super(message);
-        this.name = 'CliError';
-        this.code = code;
-        this.hint = hint;
-    }
-}
-export const usageError = (m, hint) => new CliError(m, EXIT.usage, hint);
-export const invalidError = (m, hint) => new CliError(m, EXIT.invalid, hint);
-export const credentialError = (m, hint) => new CliError(m, EXIT.credentials, hint);
+// The engine raises these too, so `instanceof CliError` holds for its errors.
+import { usageError } from '@zenera/engine';
+export { EngineError as CliError, credentialError, EXIT, invalidError, usageError, } from '@zenera/engine';
 /** One grey per background. The only 256-colour indices in the CLI. */
 export const CHROME = { dark: 245, light: 242 };
 let sniffed;

package/dist/tui/app.js

@@ -1,5 +1,6 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { TextInput } from '@inkjs/ui';
+import { display } from '@zenera/engine';
 import { addUsage, isCheckpoint, turns, zeroUsage, } from '@zenera/neo';
 import { Box, Static, Text, useApp, useInput, useStdout } from 'ink';
 import { pathToFileURL } from 'node:url';
@@ -7,7 +8,6 @@ import React, { useCallback, useContext, useEffect, useRef, useState } from 'rea
 import * as Engine from "../engine.js";
 import { History } from "../history.js";
 import { format } from "../narrate.js";
-import { display } from "../session.js";
 import { CliError } from "../term.js";
 import { hostUrls, hyperlink, hyperlinks, linkBlock, mountsOf } from "./links.js";
 import { resolveTheme, THEMES } from "./theme.js";

package/dist/tui/models.d.ts

@@ -1,5 +1,5 @@
+import type { Provider } from '@zenera/engine';
 import { type Balance, type Catalog, type CatalogEntry, type Role } from '../catalog.ts';
-import type { Provider } from '../keys.ts';
 export interface ProviderRow {
     provider: Provider;
     /** where its credential came from — `environment`, `keyring` — or '' for none */

package/dist/validate.d.ts

@@ -1,6 +1,5 @@
+import { type DeclaredRole, type KeyStore, type Liveness } from '@zenera/engine';
 import { type AnyTool, type ProjectConfig, type Runner } from '@zenera/neo';
-import { type DeclaredRole } from './audit.ts';
-import { type KeyStore, type Liveness } from './keys.ts';
 /**
  * `error` — the project will not load, or will not run.
  * `warning` — it loads, and something about it is probably not what was meant.

package/dist/validate.js

@@ -1,10 +1,8 @@
+import { SHAPES, auditModels, credentialFor, envNames, form, resolveBuild, } from '@zenera/engine';
 import { EXA_GROUP, FileSkillProvider, SANDBOX_MOUNT, Sandbox, exaTools, fileTools, frontmatter, projectRegistry, readProjectConfig, sandboxTools, selectTools, toList, } from '@zenera/neo';
 import { existsSync, mkdtempSync, readFileSync, readdirSync, realpathSync, rmSync, statSync, } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { basename, dirname, isAbsolute, join, relative, resolve } from 'node:path';
-import { auditModels, credentialFor } from "./audit.js";
-import { resolveBuild } from "./image.js";
-import { SHAPES, envNames, form } from "./keys.js";
 import { probeModels } from "./liveness.js";
 import { BuildError, ensurePodmanReady } from "./podman.js";
 import { ownVersion, staleShared } from "./scaffold.js";

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@zenera/cli",
-    "version": "1.1.36",
+    "version": "1.1.37",
     "description": "Command-line front end for @zenera/neo: agentic projects you can run, share and commit.",
     "keywords": [
         "agents",
@@ -54,8 +54,9 @@
         "@google/genai": "^2.30.0",
         "@inkjs/ui": "^2.0.0",
         "@openrouter/sdk": "^1.4.25",
-        "@zenera/neo": "^1.1.36",
-        "@zenera/view": "^1.1.36",
+        "@zenera/engine": "^1.1.37",
+        "@zenera/neo": "^1.1.37",
+        "@zenera/view": "^1.1.37",
         "google-auth-library": "^10.0.0",
         "ink": "^7.1.1",
         "openai": "^6.0.0",

package/dist/audit.d.ts

@@ -1,58 +0,0 @@
-import { type ModelRequirement } from '@zenera/neo';
-import { type KeyOwner, type KeyStore } from './keys.ts';
-/** Which key of the config named a reference: `model:`/`models:` or `embedding:`/`embeddings:`. */
-export type DeclaredRole = 'model' | 'embedding';
-export interface ModelIssue {
-    /** the model as the config names it: an alias, or the ref itself */
-    name: string;
-    /** what the config declared it for */
-    role: DeclaredRole;
-    /** the provider it resolves to */
-    provider: string;
-    /** the variable that would carry the credential */
-    env: string;
-    /** `missing` — nothing to authenticate with. `dead` — rejected when checked.
-     *  `blocked` — accepted, and then refused by the account behind it. */
-    reason: 'missing' | 'dead' | 'blocked';
-    /** the provider's own words, when it was the one to say no */
-    detail?: string;
-    /** what to do about a refusal that a new key would not fix */
-    fix?: string;
-    /** the keyring provider the fix names, when the kind is one of them */
-    add?: KeyOwner;
-}
-/**
- * Whether a requirement is actually met, and under which variable.
- *
- * `satisfied` is the library's answer and it is about api keys, which is the
- * wrong question for Vertex: that kind is `keyOptional` because it can
- * authenticate from a service-account file instead. So both of its variables
- * are looked for, along with the file `gcloud` leaves behind.
- *
- * The variable named back is the one that is actually set, because a report
- * that named `VERTEX_API_KEY` while the audit silently checked
- * `GOOGLE_APPLICATION_CREDENTIALS` would be two answers to one question, and
- * the wrong one is the one people would act on. With nothing set there is no
- * such answer, so it names the form the provider is usually reached by.
- */
-export declare function credentialFor(need: ModelRequirement): {
-    env: string;
-    present: boolean;
-};
-/**
- * Reports the models a run could not reach. Best effort by design: a config
- * that will not parse, or that names a provider that does not exist, is the
- * loader's to report — precisely, and with the offending key named. Guessing
- * at it here would only produce a worse version of the same message.
- *
- * Call *after* `KeyStore.materialize()`, so the keyring's keys are as visible
- * here as they will be to the library.
- */
-export declare function auditModels(projectDir: string, store: KeyStore): ModelIssue[];
-/**
- * One line, and the command that fixes it. A warning nobody can act on is
- * noise, so the fix is part of the sentence rather than something to go and
- * look up.
- */
-export declare function describeIssue(issue: ModelIssue): string;
-//# sourceMappingURL=audit.d.ts.map

package/dist/audit.js

@@ -1,148 +0,0 @@
-import { projectRegistry, readProjectConfig, } from '@zenera/neo';
-import { envNames, form, gcloudAdc, isOwner, isProvider, SHAPES, } from "./keys.js";
-import { bold, dim } from "./term.js";
-/**
- * Every model the project names, keyed by how one would refer to it.
- *
- * The `models:` table comes first so a declared alias keeps its own name in the
- * report; a `model:` that names one collapses onto it rather than appearing
- * twice, and a `model:` that names no alias is a shorthand standing for itself.
- *
- * Embeddings are walked the same way and kept in their own list: an alias may
- * legitimately appear under both keys meaning two different things, and they
- * are two credentials to check either way.
- */
-function declared(config) {
-    // The schema widens `reasoningEffort` to `string` on purpose, which is the
-    // one thing keeping a config's model spec from being a `ModelSpec`. The
-    // loader hands the same cast to `models.model()` for the same reason.
-    const models = new Map(Object.entries(config.models ?? {}));
-    const add = (into, ref) => {
-        if (ref && !into.has(ref)) {
-            into.set(ref, ref);
-        }
-    };
-    add(models, config.model);
-    for (const agent of config.agents) {
-        add(models, agent.model);
-    }
-    const embeddings = new Map(Object.entries(config.embeddings ?? {}));
-    add(embeddings, config.embedding);
-    return new Map([
-        ['model', models],
-        ['embedding', embeddings],
-    ]);
-}
-/**
- * Whether a requirement is actually met, and under which variable.
- *
- * `satisfied` is the library's answer and it is about api keys, which is the
- * wrong question for Vertex: that kind is `keyOptional` because it can
- * authenticate from a service-account file instead. So both of its variables
- * are looked for, along with the file `gcloud` leaves behind.
- *
- * The variable named back is the one that is actually set, because a report
- * that named `VERTEX_API_KEY` while the audit silently checked
- * `GOOGLE_APPLICATION_CREDENTIALS` would be two answers to one question, and
- * the wrong one is the one people would act on. With nothing set there is no
- * such answer, so it names the form the provider is usually reached by.
- */
-export function credentialFor(need) {
-    if (need.gateway) {
-        return { env: need.apiKeyEnv, present: need.satisfied };
-    }
-    const provider = isProvider(need.kind) ? need.kind : undefined;
-    // A provider with a file form can authenticate without an api key, which is
-    // the only thing `satisfied` knows how to look for.
-    if (provider && SHAPES[provider].forms.some((f) => f.holds === 'file')) {
-        const set = envNames(provider).find((name) => process.env[name]);
-        return { env: set ?? form(provider).env, present: Boolean(set) || Boolean(gcloudAdc()) };
-    }
-    return { env: need.apiKeyEnv, present: need.satisfied };
-}
-/**
- * Reports the models a run could not reach. Best effort by design: a config
- * that will not parse, or that names a provider that does not exist, is the
- * loader's to report — precisely, and with the offending key named. Guessing
- * at it here would only produce a worse version of the same message.
- *
- * Call *after* `KeyStore.materialize()`, so the keyring's keys are as visible
- * here as they will be to the library.
- */
-export function auditModels(projectDir, store) {
-    let config;
-    try {
-        config = readProjectConfig(projectDir).config;
-    }
-    catch {
-        return [];
-    }
-    const registry = projectRegistry(config);
-    const issues = [];
-    for (const [role, refs] of declared(config)) {
-        for (const [name, ref] of refs) {
-            let need;
-            try {
-                need = registry.requirement(ref);
-            }
-            catch {
-                continue;
-            }
-            const { env, present } = credentialFor(need);
-            const provider = need.gateway && isOwner(need.gateway)
-                ? need.gateway
-                : isProvider(need.kind)
-                    ? need.kind
-                    : undefined;
-            if (!present) {
-                issues.push({
-                    name,
-                    role,
-                    provider: need.provider,
-                    env,
-                    reason: 'missing',
-                    add: provider,
-                });
-                continue;
-            }
-            // A key that the provider itself rejected last time it was asked.
-            // Said as a warning rather than an error because a key can be
-            // reinstated between the check and the run, and a stale verdict must
-            // not be the thing that stops a run from being attempted.
-            const check = provider ? store.active(provider)?.check : undefined;
-            if (check?.state === 'dead' || check?.state === 'blocked') {
-                issues.push({
-                    name,
-                    role,
-                    provider: need.provider,
-                    env,
-                    reason: check.state,
-                    detail: check.detail,
-                    fix: check.fix,
-                    add: provider,
-                });
-            }
-        }
-    }
-    return issues;
-}
-/**
- * One line, and the command that fixes it. A warning nobody can act on is
- * noise, so the fix is part of the sentence rather than something to go and
- * look up.
- */
-export function describeIssue(issue) {
-    const what = `${bold(issue.name)} (${issue.provider}${issue.role === 'embedding' ? ', embedding' : ''})`;
-    if (issue.reason === 'missing') {
-        const fix = issue.add ? `zen key add ${issue.add}` : `set ${issue.env}`;
-        return `${what} has no credential — ${issue.env} is not set; ${dim(fix)}`;
-    }
-    const why = issue.detail ? `: ${issue.detail}` : '';
-    if (issue.reason === 'blocked') {
-        const list = `zen models ls --${issue.role === 'embedding' ? 'embeddings' : 'chat'}`;
-        return `${what} authenticated and was then refused${why} — ${dim(issue.fix ?? list)}`;
-    }
-    const fix = `zen key check ${issue.add ?? ''}`.trim();
-    return `${what} was rejected when last checked${why} — ${dim(fix)}`;
-}
-//# sourceMappingURL=audit.js.map

package/dist/env.d.ts

@@ -1,20 +0,0 @@
-/** The file, relative to the project directory. */
-export declare const ENV_FILE = ".env";
-export interface ProjectEnv {
-    /** the file it was read from */
-    path: string;
-    /** every name the file declares, whether or not its value won */
-    names: string[];
-}
-/**
- * Reads `<dir>/.env` into `process.env`, without overwriting anything already
- * set, and returns the names it found. A project with no such file is not a
- * problem to report — most have none — so the answer is simply `undefined`.
- *
- * The names are returned in full, including the ones the environment already
- * answered: the variable is in play either way, and the sandbox forwards by
- * name, so what it needs to know is which names matter and not which of the
- * two sources supplied them.
- */
-export declare function loadProjectEnv(dir: string): ProjectEnv | undefined;
-//# sourceMappingURL=env.d.ts.map

package/dist/env.js

@@ -1,65 +0,0 @@
-import { existsSync, readFileSync } from 'node:fs';
-import { isAbsolute, join, resolve } from 'node:path';
-import { parseEnv } from 'node:util';
-import { FILE_ENVS } from "./keys.js";
-// ---------------------------------------------------------------------------
-// The project's `.env`
-//
-// A project is a directory, and some of what it needs to run is particular to
-// it: the token for the service it talks to, the base url of the environment
-// it talks to it in. The keyring answers "what can this machine pay for"; this
-// answers "what does this project need", and the two are different questions
-// often enough to be worth two places.
-//
-// Precedence is the same one everything else here uses — the real environment
-// always wins. What is already set in the shell is left alone, this file fills
-// the gaps, and the keyring fills whatever is still missing after that. So a
-// variable exported for one command still overrides the file, which is the
-// behaviour anybody typing `FOO=bar zen run` is expecting.
-//
-// The names, not the values, are what leaves this module: they are what the
-// sandbox forwards, and forwarding by name is what keeps a secret out of an
-// argv. See `forwarded()` in sandbox.ts for the rest of that story.
-// ---------------------------------------------------------------------------
-/** The file, relative to the project directory. */
-export const ENV_FILE = '.env';
-/**
- * Reads `<dir>/.env` into `process.env`, without overwriting anything already
- * set, and returns the names it found. A project with no such file is not a
- * problem to report — most have none — so the answer is simply `undefined`.
- *
- * The names are returned in full, including the ones the environment already
- * answered: the variable is in play either way, and the sandbox forwards by
- * name, so what it needs to know is which names matter and not which of the
- * two sources supplied them.
- */
-export function loadProjectEnv(dir) {
-    const path = join(dir, ENV_FILE);
-    if (!existsSync(path)) {
-        return undefined;
-    }
-    const names = [];
-    for (const [name, value] of Object.entries(parseEnv(readFileSync(path, 'utf8')))) {
-        if (value === undefined) {
-            continue;
-        }
-        names.push(name);
-        // An empty string is not an answer: tools test for absence, and a
-        // commented-out line someone half-filled in should not shadow a key
-        // the keyring has.
-        if (!process.env[name]) {
-            process.env[name] = located(dir, name, value);
-        }
-    }
-    return { path, names };
-}
-/**
- * A service-account file is normally kept beside the `.env` that names it, so
- * a relative path there means relative to the *project* — not to wherever the
- * command happened to be run, which is what both the Google SDK and podman's
- * bind mount would otherwise make of it.
- */
-function located(dir, name, value) {
-    return FILE_ENVS.includes(name) && !isAbsolute(value) ? resolve(dir, value) : value;
-}
-//# sourceMappingURL=env.js.map