hushenv 0.1.0

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/NOTICE

@@ -0,0 +1,2 @@
+hushenv
+Copyright 2026 Simplyxity Ltd

package/README.md

@@ -0,0 +1,106 @@
+# hushenv
+
+Keeps your secrets hush-hush 🤫 — a local secret manager for the agent era, starting with your `.env`.
+
+Your `.env` files hold **references**, not secrets:
+
+```dotenv
+NEXTAUTH_URL=http://localhost:3000
+DATABASE_URL=postgres://app:{hushenv.DB_PASSWORD}@localhost:5432/app
+RESEND_KEY={hushenv.RESEND_KEY}
+```
+
+Real values live AES-256-GCM-encrypted in `~/.hushenv/vault.json`, with the
+master key in your OS keychain (macOS Keychain / Windows Credential Manager).
+Plaintext exists in exactly one place: the child process environment, in
+memory, at `hushenv run` time. The `.env` file is safe to commit and safe for
+AI agents to read.
+
+## Quickstart
+
+```bash
+hushenv init                       # master key -> OS keychain, empty vault
+hushenv set DB_PASSWORD            # hidden prompt
+hushenv set RESEND_KEY --stdin     # or pipe it in
+hushenv run -- pnpm dev            # resolves refs from ./.env, injects, runs
+hushenv run -f .env.local -- pnpm dev
+```
+
+## Commands
+
+| Command | What it does |
+|---|---|
+| `hushenv init` | Create the master key (keychain) and an empty vault |
+| `hushenv set <name> [value]` | Store a secret. Hidden prompt by default; `--stdin` to pipe. Positional value is discouraged (shell history). |
+| `hushenv get <name>` | Reveal a value. Requires an interactive TTY + confirmation; `--force` to bypass (use sparingly). |
+| `hushenv ls` | List names and update dates. Never values. |
+| `hushenv rm <name>` | Delete a secret |
+| `hushenv run [-f file]... -- <cmd>` | Resolve refs and run the command with secrets injected |
+
+Reference syntax: `{hushenv.NAME}` — whole-value or embedded inside a larger
+string. `{mysm.NAME}` and `{mysmtool.NAME}` are accepted as legacy aliases.
+
+## Semantics
+
+- Multiple `-f` files: loaded in order, the **first** occurrence of a key wins.
+- Existing `process.env` variables are **not** overridden by file values
+  (dotenv convention).
+- Missing refs **fail fast** before your app starts, with the exact
+  `hushenv set` commands to fix it. Exit code 2.
+- Exit codes: `0` ok · `1` error · `2` missing secret.
+
+## No keychain? (CI, containers)
+
+Set the master key via the environment instead:
+
+```bash
+export HUSHENV_MASTER_KEY="<32 bytes, base64>"
+```
+
+`hushenv init` prints exactly this fallback if no OS keychain is reachable.
+
+## Security model — honest version
+
+What this protects against:
+
+- Agents or tools reading secrets from `.env` files (they only see refs)
+- Secrets leaking into git history
+- Vault file theft without the OS keychain (ciphertext only)
+- Ciphertext swapping between entries (AES-GCM AAD binds value to name)
+
+What it does **not** protect against:
+
+- `hushenv run -- env` prints that project's resolved secrets — scoping
+  arrives with per-project grants in v1
+- `hushenv get --force` from a non-interactive shell — pair it with an agent
+  deny rule, e.g. `Bash(hushenv get*)` in Claude Code settings
+- Malware running as your user with an unlocked keychain — same limit as any
+  local secret manager
+
+## Repo layout
+
+```
+packages/vault-core   engine: crypto, keychain, vault storage (name-agnostic)
+apps/cli              the hushenv CLI: ref resolution, run, prompts
+```
+
+`vault-core` never imports anything env-file- or CLI-specific. Future
+surfaces (tray UI, MCP broker) sit on the same engine.
+
+## Development
+
+```bash
+pnpm install
+pnpm build
+pnpm test
+pnpm --filter hushenv dev -- --help   # run from source
+```
+
+To use your dev build globally: `cd apps/cli && pnpm link --global`
+(run `pnpm setup` once first if pnpm complains about a global bin dir).
+
+## Roadmap
+
+v1: `import` (migrate an existing `.env`), append-only audit log,
+per-project grants with strict mode. v2: secret versions, rotation warnings,
+tray UI.

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { NotInitializedError, SecretNotFoundError } from '@hushenv/vault-core';
+import { getCommand } from './commands/get.js';
+import { initCommand } from './commands/init.js';
+import { lsCommand } from './commands/ls.js';
+import { rmCommand } from './commands/rm.js';
+import { runCommand } from './commands/run.js';
+import { setCommand } from './commands/set.js';
+const program = new Command();
+program
+    .name('hushenv')
+    .description('Local secret manager for the agent era.\nYour .env holds {hushenv.X} refs; plaintext exists only in child process memory.')
+    .version('0.1.0')
+    .enablePositionalOptions()
+    .showHelpAfterError();
+program
+    .command('init')
+    .description('Create the master key (OS keychain) and an empty vault')
+    .action(initCommand);
+program
+    .command('set')
+    .description('Store a secret (hidden prompt by default)')
+    .argument('<name>', 'secret name, e.g. DB_PASSWORD')
+    .argument('[value]', 'value (discouraged: lands in shell history)')
+    .option('--stdin', 'read the value from stdin')
+    .action(setCommand);
+program
+    .command('get')
+    .description('Reveal a secret (interactive confirmation required)')
+    .argument('<name>')
+    .option('--force', 'skip the TTY confirmation gate')
+    .action(getCommand);
+program.command('ls').description('List secret names (never values)').action(lsCommand);
+program.command('rm').description('Delete a secret').argument('<name>').action(rmCommand);
+program
+    .command('run')
+    .description('Resolve {hushenv.X} refs from env file(s) and run a command')
+    .option('-f, --file <path>', 'env file to load (repeatable; first wins)', collect, [])
+    .passThroughOptions()
+    .argument('<cmd...>', 'command to run, after --')
+    .action((cmd, opts) => {
+    const files = opts.file.length > 0 ? opts.file : ['.env'];
+    runCommand(files, cmd);
+});
+function collect(value, previous) {
+    return [...previous, value];
+}
+try {
+    await program.parseAsync(process.argv);
+}
+catch (err) {
+    handleError(err);
+}
+function handleError(err) {
+    if (err instanceof SecretNotFoundError) {
+        console.error(`x ${err.message}`);
+        process.exitCode = 2;
+    }
+    else if (err instanceof NotInitializedError) {
+        console.error(`x ${err.message}`);
+        process.exitCode = 1;
+    }
+    else if (err instanceof Error && err.name === 'ExitPromptError') {
+        process.exitCode = 1;
+    }
+    else {
+        console.error(`x ${err instanceof Error ? err.message : String(err)}`);
+        process.exitCode = 1;
+    }
+}

package/dist/commands/get.d.ts

@@ -0,0 +1,9 @@
+export interface GetOptions {
+    force?: boolean;
+}
+/**
+ * TTY gate: revealing plaintext requires an interactive terminal unless
+ * --force is passed. Non-interactive shells (CI, agents) fail the gate by
+ * design.
+ */
+export declare function getCommand(name: string, opts: GetOptions): Promise<void>;

package/dist/commands/get.js

@@ -0,0 +1,24 @@
+import { confirm } from '@inquirer/prompts';
+import { getSecretValue } from '@hushenv/vault-core';
+/**
+ * TTY gate: revealing plaintext requires an interactive terminal unless
+ * --force is passed. Non-interactive shells (CI, agents) fail the gate by
+ * design.
+ */
+export async function getCommand(name, opts) {
+    if (!opts.force) {
+        if (!process.stdin.isTTY || !process.stdout.isTTY) {
+            console.error('x `hushenv get` reveals plaintext and requires an interactive terminal.');
+            console.error('  Non-interactive callers must pass --force explicitly.');
+            process.exitCode = 1;
+            return;
+        }
+        const ok = await confirm({ message: `Reveal "${name}" in plaintext?`, default: false });
+        if (!ok) {
+            console.error('Aborted.');
+            process.exitCode = 1;
+            return;
+        }
+    }
+    process.stdout.write(getSecretValue(name) + '\n');
+}

package/dist/commands/init.d.ts

@@ -0,0 +1 @@
+export declare function initCommand(): void;

package/dist/commands/init.js

@@ -0,0 +1,33 @@
+import { KeychainUnavailableError, createAndStoreMasterKey, hasStoredMasterKey, initVault, masterKeyFromEnv, vaultPath, } from '@hushenv/vault-core';
+export function initCommand() {
+    if (masterKeyFromEnv()) {
+        console.log('Using master key from HUSHENV_MASTER_KEY (OS keychain skipped).');
+    }
+    else if (hasStoredMasterKey()) {
+        console.log('Master key already present in the OS keychain.');
+    }
+    else {
+        try {
+            createAndStoreMasterKey();
+            console.log('* Generated a master key and stored it in the OS keychain.');
+        }
+        catch (err) {
+            if (err instanceof KeychainUnavailableError) {
+                console.error(`x ${err.message}`);
+                console.error('\nFallback: add this to your shell profile, then re-run `hushenv init`:');
+                console.error(`  export HUSHENV_MASTER_KEY="${err.fallbackKey}"`);
+                process.exitCode = 1;
+                return;
+            }
+            throw err;
+        }
+    }
+    const { created } = initVault();
+    console.log(created ? `* Created vault at ${vaultPath()}` : `Vault already exists at ${vaultPath()}`);
+    if (created) {
+        console.log('\nNext steps:');
+        console.log('  hushenv set MY_SECRET            # store a value (hidden prompt)');
+        console.log('  echo {hushenv.MY_SECRET} in .env # reference it');
+        console.log('  hushenv run -- pnpm dev          # run with secrets injected');
+    }
+}

package/dist/commands/ls.d.ts

@@ -0,0 +1 @@
+export declare function lsCommand(): void;

package/dist/commands/ls.js

@@ -0,0 +1,12 @@
+import { listSecrets } from '@hushenv/vault-core';
+export function lsCommand() {
+    const secrets = listSecrets();
+    if (secrets.length === 0) {
+        console.log('Vault is empty. Add a secret with: hushenv set NAME');
+        return;
+    }
+    const width = Math.max(...secrets.map((s) => s.name.length));
+    for (const s of secrets) {
+        console.log(`${s.name.padEnd(width)}  updated ${s.updatedAt.slice(0, 10)}`);
+    }
+}

package/dist/commands/rm.d.ts

@@ -0,0 +1 @@
+export declare function rmCommand(name: string): void;

package/dist/commands/rm.js

@@ -0,0 +1,10 @@
+import { deleteSecret } from '@hushenv/vault-core';
+export function rmCommand(name) {
+    if (deleteSecret(name)) {
+        console.log(`* Removed ${name}.`);
+    }
+    else {
+        console.error(`x Secret "${name}" not found.`);
+        process.exitCode = 2;
+    }
+}

package/dist/commands/run.d.ts

@@ -0,0 +1,6 @@
+/**
+ * The core invariant: plaintext exists only in the child process
+ * environment, in memory, at exec time. Nothing resolved is ever written to
+ * disk.
+ */
+export declare function runCommand(files: string[], cmd: string[]): void;

package/dist/commands/run.js

@@ -0,0 +1,40 @@
+import spawn from 'cross-spawn';
+import { decryptValue, getMasterKey, loadVault } from '@hushenv/vault-core';
+import { loadEnvFiles } from '../env-files.js';
+import { resolveRefs } from '../resolve.js';
+/**
+ * The core invariant: plaintext exists only in the child process
+ * environment, in memory, at exec time. Nothing resolved is ever written to
+ * disk.
+ */
+export function runCommand(files, cmd) {
+    if (cmd.length === 0) {
+        throw new Error('No command given. Usage: hushenv run [-f file] -- <command...>');
+    }
+    const raw = loadEnvFiles(files);
+    const key = getMasterKey();
+    const vault = loadVault();
+    const { resolved, missing } = resolveRefs(raw, (name) => {
+        const entry = vault.secrets[name];
+        return entry ? decryptValue(key, name, entry) : undefined;
+    });
+    if (missing.length > 0) {
+        console.error(`x ${missing.length} secret(s) referenced but not in the vault:`);
+        for (const name of missing)
+            console.error(`    ${name}`);
+        console.error('\n  Add them with:');
+        for (const name of missing)
+            console.error(`    hushenv set ${name}`);
+        process.exitCode = 2;
+        return;
+    }
+    const childEnv = { ...resolved, ...process.env };
+    const child = spawn(cmd[0], cmd.slice(1), { stdio: 'inherit', env: childEnv });
+    child.on('error', (err) => {
+        console.error(`x Failed to start "${cmd[0]}": ${err.message}`);
+        process.exitCode = 1;
+    });
+    child.on('exit', (code, signal) => {
+        process.exitCode = signal ? 1 : code ?? 1;
+    });
+}

package/dist/commands/set.d.ts

@@ -0,0 +1,9 @@
+export interface SetOptions {
+    stdin?: boolean;
+}
+export declare function setCommand(name: string, positionalValue: string | undefined, opts: SetOptions): Promise<void>;
+/**
+ * PowerShell 5.1 prepends a UTF-8 BOM when piping a string into a native
+ * process, which would silently corrupt the stored secret.
+ */
+export declare function normalizeStdinValue(raw: string): string;

package/dist/commands/set.js

@@ -0,0 +1,34 @@
+import { password } from '@inquirer/prompts';
+import { setSecret } from '@hushenv/vault-core';
+export async function setCommand(name, positionalValue, opts) {
+    let value;
+    if (opts.stdin) {
+        value = normalizeStdinValue(await readStdin());
+    }
+    else if (positionalValue !== undefined) {
+        console.error('Warning: the value was passed on the command line and may be stored in your shell history.');
+        console.error('Prefer `hushenv set NAME` (hidden prompt) or `--stdin`.');
+        value = positionalValue;
+    }
+    else {
+        value = await password({ message: `Value for ${name}:`, mask: '*' });
+    }
+    setSecret(name, value);
+    console.log(`* Stored ${name} (encrypted).`);
+}
+/**
+ * PowerShell 5.1 prepends a UTF-8 BOM when piping a string into a native
+ * process, which would silently corrupt the stored secret.
+ */
+export function normalizeStdinValue(raw) {
+    return raw.replace(/^\uFEFF/, '').replace(/\r?\n$/, '');
+}
+function readStdin() {
+    return new Promise((resolve, reject) => {
+        let data = '';
+        process.stdin.setEncoding('utf8');
+        process.stdin.on('data', (chunk) => (data += chunk));
+        process.stdin.on('end', () => resolve(data));
+        process.stdin.on('error', reject);
+    });
+}

package/dist/env-files.d.ts

@@ -0,0 +1,2 @@
+/** Loads env files in order; the FIRST occurrence of a key wins. */
+export declare function loadEnvFiles(files: string[]): Record<string, string>;

package/dist/env-files.js

@@ -0,0 +1,17 @@
+import fs from 'node:fs';
+import { parse } from 'dotenv';
+/** Loads env files in order; the FIRST occurrence of a key wins. */
+export function loadEnvFiles(files) {
+    const out = {};
+    for (const file of files) {
+        if (!fs.existsSync(file)) {
+            throw new Error(`Env file not found: ${file}`);
+        }
+        const parsed = parse(fs.readFileSync(file, 'utf8'));
+        for (const [key, value] of Object.entries(parsed)) {
+            if (!(key in out))
+                out[key] = value;
+        }
+    }
+    return out;
+}

package/dist/resolve.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Reference syntax: {hushenv.NAME}. The mysm/mysmtool prefixes are accepted
+ * as legacy aliases.
+ */
+export declare const REF_RE: RegExp;
+export interface ResolveResult {
+    resolved: Record<string, string>;
+    missing: string[];
+    used: string[];
+}
+/** Collect every referenced secret name across all values. */
+export declare function collectRefs(values: Record<string, string>): string[];
+/**
+ * Substitutes refs (including refs embedded inside larger strings) using the
+ * lookup. Missing names are collected, not thrown - the caller decides how
+ * to fail.
+ */
+export declare function resolveRefs(values: Record<string, string>, lookup: (name: string) => string | undefined): ResolveResult;

package/dist/resolve.js

@@ -0,0 +1,37 @@
+/**
+ * Reference syntax: {hushenv.NAME}. The mysm/mysmtool prefixes are accepted
+ * as legacy aliases.
+ */
+export const REF_RE = /\{(?:hushenv|mysm(?:tool)?)\.([A-Za-z_][A-Za-z0-9_]*)\}/g;
+/** Collect every referenced secret name across all values. */
+export function collectRefs(values) {
+    const names = new Set();
+    for (const value of Object.values(values)) {
+        for (const match of value.matchAll(REF_RE)) {
+            names.add(match[1]);
+        }
+    }
+    return [...names];
+}
+/**
+ * Substitutes refs (including refs embedded inside larger strings) using the
+ * lookup. Missing names are collected, not thrown - the caller decides how
+ * to fail.
+ */
+export function resolveRefs(values, lookup) {
+    const missing = new Set();
+    const used = new Set();
+    const resolved = {};
+    for (const [key, value] of Object.entries(values)) {
+        resolved[key] = value.replace(REF_RE, (whole, name) => {
+            const secret = lookup(name);
+            if (secret === undefined) {
+                missing.add(name);
+                return whole;
+            }
+            used.add(name);
+            return secret;
+        });
+    }
+    return { resolved, missing: [...missing], used: [...used] };
+}

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "hushenv",
+  "version": "0.1.0",
+  "description": "Local secret manager for the agent era - encrypted vault, {hushenv.X} refs in .env, plaintext only at runtime.",
+  "type": "module",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hushenv/hushenv.git",
+    "directory": "apps/cli"
+  },
+  "homepage": "https://github.com/hushenv/hushenv#readme",
+  "bugs": {
+    "url": "https://github.com/hushenv/hushenv/issues"
+  },
+  "keywords": [
+    "secrets",
+    "env",
+    "dotenv",
+    "vault",
+    "keychain",
+    "security",
+    "cli"
+  ],
+  "bin": {
+    "hushenv": "./dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "NOTICE"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "@inquirer/prompts": "^8.5.0",
+    "commander": "^15.0.0",
+    "cross-spawn": "^7.0.6",
+    "dotenv": "^17.4.0",
+    "@hushenv/vault-core": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/cross-spawn": "^6.0.6",
+    "@types/node": "^22.10.0",
+    "tsx": "^4.22.0",
+    "typescript": "^5.5.0",
+    "vitest": "^4.1.0"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "dev": "tsx src/cli.ts",
+    "test": "vitest run"
+  }
+}