happy-stacks 0.3.0 → 0.5.0

package/scripts/env.mjs

@@ -0,0 +1,150 @@
+import './utils/env/env.mjs';
+import { parseArgs } from './utils/cli/args.mjs';
+import { printResult, wantsHelp, wantsJson } from './utils/cli/cli.mjs';
+import { ensureEnvFilePruned, ensureEnvFileUpdated } from './utils/env/env_file.mjs';
+import { parseEnvToObject } from './utils/env/dotenv.mjs';
+import { resolveStackEnvPath } from './utils/paths/paths.mjs';
+import { readTextOrEmpty } from './utils/fs/ops.mjs';
+
+function resolveTargetEnvPath() {
+  // If we're already running under a stack wrapper, respect it.
+  const explicit = (process.env.HAPPY_STACKS_ENV_FILE ?? process.env.HAPPY_LOCAL_ENV_FILE ?? '').trim();
+  if (explicit) return explicit;
+
+  // Self-host default: no stacks knowledge required; persist in the main stack env file.
+  return resolveStackEnvPath('main').envPath;
+}
+
+async function main() {
+  const argv = process.argv.slice(2);
+  const { flags } = parseArgs(argv);
+  const json = wantsJson(argv, { flags });
+
+  const helpText = [
+    '[env] usage:',
+    '  happys env set KEY=VALUE [KEY2=VALUE2...]',
+    '  happys env unset KEY [KEY2...]',
+    '  happys env get KEY',
+    '  happys env list',
+    '  happys env path',
+    '',
+    'defaults:',
+    '  - If running under a stack wrapper (HAPPY_STACKS_ENV_FILE is set), edits that stack env file.',
+    '  - Otherwise, edits the main stack env file (~/.happy/stacks/main/env).',
+    '',
+    'notes:',
+    '  - Changes take effect on next stack/daemon start (restart to apply).',
+  ].join('\n');
+
+  if (wantsHelp(argv, { flags })) {
+    printResult({
+      json,
+      data: {
+        usage:
+          'happys env set KEY=VALUE [KEY2=VALUE2...] | unset KEY [KEY2...] | get KEY | list | path [--json]',
+      },
+      text: helpText,
+    });
+    return;
+  }
+
+  const positionals = argv.filter((a) => !a.startsWith('--'));
+  const subcmd = (positionals[0] ?? '').trim() || 'help';
+  const envPath = resolveTargetEnvPath();
+
+  if (subcmd === 'help') {
+    printResult({
+      json,
+      data: {
+        usage: 'happys env set|unset|get|list|path [--json]',
+      },
+      text: helpText,
+    });
+    return;
+  }
+
+  if (subcmd === 'path') {
+    printResult({
+      json,
+      data: { ok: true, envPath },
+      text: envPath,
+    });
+    return;
+  }
+
+  const raw = await readTextOrEmpty(envPath);
+  const parsed = parseEnvToObject(raw);
+
+  if (subcmd === 'list') {
+    const keys = Object.keys(parsed ?? {}).sort((a, b) => a.localeCompare(b));
+    const text = [
+      `[env] path: ${envPath}`,
+      ...keys.map((k) => `${k}=${parsed[k] ?? ''}`),
+    ].join('\n');
+    printResult({ json, data: { ok: true, envPath, env: parsed }, text });
+    return;
+  }
+
+  if (subcmd === 'get') {
+    const key = (positionals[1] ?? '').trim();
+    if (!key) {
+      throw new Error('[env] usage: happys env get KEY');
+    }
+    const value = Object.prototype.hasOwnProperty.call(parsed, key) ? parsed[key] : null;
+    printResult({
+      json,
+      data: { ok: true, envPath, key, value },
+      text: value == null ? '' : String(value),
+    });
+    return;
+  }
+
+  if (subcmd === 'set') {
+    const pairs = positionals.slice(1);
+    if (!pairs.length) {
+      throw new Error('[env] usage: happys env set KEY=VALUE [KEY2=VALUE2...]');
+    }
+    const updates = pairs.map((p) => {
+      const idx = p.indexOf('=');
+      if (idx <= 0) {
+        throw new Error(`[env] set: expected KEY=VALUE, got: ${p}`);
+      }
+      const key = p.slice(0, idx).trim();
+      const value = p.slice(idx + 1);
+      if (!key) {
+        throw new Error(`[env] set: invalid key in: ${p}`);
+      }
+      return { key, value };
+    });
+    await ensureEnvFileUpdated({ envPath, updates });
+    const updatedKeys = updates.map((u) => u.key);
+    printResult({
+      json,
+      data: { ok: true, envPath, updatedKeys },
+      text: `[env] ok: set ${updatedKeys.join(', ')}\n[env] path: ${envPath}`,
+    });
+    return;
+  }
+
+  if (subcmd === 'unset' || subcmd === 'remove' || subcmd === 'rm') {
+    const keys = positionals.slice(1).map((k) => k.trim()).filter(Boolean);
+    if (!keys.length) {
+      throw new Error('[env] usage: happys env unset KEY [KEY2...]');
+    }
+    await ensureEnvFilePruned({ envPath, removeKeys: keys });
+    printResult({
+      json,
+      data: { ok: true, envPath, removedKeys: keys },
+      text: `[env] ok: unset ${keys.join(', ')}\n[env] path: ${envPath}`,
+    });
+    return;
+  }
+
+  throw new Error(`[env] unknown subcommand: ${subcmd}\n[env] usage: happys env set|unset|get|list|path`);
+}
+
+main().catch((err) => {
+  console.error('[env] failed:', err);
+  process.exit(1);
+});
+

package/scripts/env_cmd.test.mjs

@@ -0,0 +1,128 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { spawn } from 'node:child_process';
+import { mkdtemp, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+function runNode(args, { cwd, env }) {
+  return new Promise((resolve, reject) => {
+    const cleanEnv = {};
+    for (const [k, v] of Object.entries(env ?? {})) {
+      if (v == null) continue;
+      cleanEnv[k] = String(v);
+    }
+    const proc = spawn(process.execPath, args, { cwd, env: cleanEnv, stdio: ['ignore', 'pipe', 'pipe'] });
+    let stdout = '';
+    let stderr = '';
+    proc.stdout.on('data', (d) => (stdout += String(d)));
+    proc.stderr.on('data', (d) => (stderr += String(d)));
+    proc.on('error', reject);
+    proc.on('exit', (code) => resolve({ code: code ?? 0, stdout, stderr }));
+  });
+}
+
+test('happys env path defaults to main stack env file when no explicit env file is set', async () => {
+  const scriptsDir = dirname(fileURLToPath(import.meta.url));
+  const rootDir = dirname(scriptsDir);
+  const tmp = await mkdtemp(join(tmpdir(), 'happy-stacks-env-cmd-'));
+
+  const storageDir = join(tmp, 'storage');
+  const homeDir = join(tmp, 'home');
+  await mkdir(storageDir, { recursive: true });
+  await mkdir(homeDir, { recursive: true });
+
+  const baseEnv = {
+    ...process.env,
+    // Prevent loading the user's real ~/.happy-stacks/.env via canonical discovery.
+    HAPPY_STACKS_HOME_DIR: homeDir,
+    HAPPY_STACKS_STORAGE_DIR: storageDir,
+  };
+
+  const res = await runNode([join(rootDir, 'scripts', 'env.mjs'), 'path', '--json'], {
+    cwd: rootDir,
+    env: baseEnv,
+  });
+  assert.equal(res.code, 0, `expected exit 0, got ${res.code}\nstdout:\n${res.stdout}\nstderr:\n${res.stderr}`);
+
+  const out = JSON.parse(res.stdout || '{}');
+  assert.equal(out.ok, true);
+  assert.ok(
+    typeof out.envPath === 'string' && out.envPath.endsWith('/main/env'),
+    `expected main env path to end with /main/env, got: ${out.envPath}`
+  );
+});
+
+test('happys env edits the explicit stack env file when HAPPY_STACKS_ENV_FILE is set', async () => {
+  const scriptsDir = dirname(fileURLToPath(import.meta.url));
+  const rootDir = dirname(scriptsDir);
+  const tmp = await mkdtemp(join(tmpdir(), 'happy-stacks-env-cmd-'));
+
+  const storageDir = join(tmp, 'storage');
+  const homeDir = join(tmp, 'home');
+  const stackName = 'exp1';
+  const envPath = join(storageDir, stackName, 'env');
+  await mkdir(dirname(envPath), { recursive: true });
+  await mkdir(homeDir, { recursive: true });
+
+  const baseEnv = {
+    ...process.env,
+    HAPPY_STACKS_HOME_DIR: homeDir,
+    HAPPY_STACKS_STORAGE_DIR: storageDir,
+    HAPPY_STACKS_ENV_FILE: envPath,
+  };
+
+  const res = await runNode([join(rootDir, 'scripts', 'env.mjs'), 'set', 'FOO=bar'], { cwd: rootDir, env: baseEnv });
+  assert.equal(res.code, 0, `expected exit 0, got ${res.code}\nstdout:\n${res.stdout}\nstderr:\n${res.stderr}`);
+
+  const raw = await readFile(envPath, 'utf-8');
+  assert.ok(raw.includes('FOO=bar'), `expected FOO in explicit env file\n${raw}`);
+});
+
+test('happys env (no subcommand) prints usage and exits 0', async () => {
+  const scriptsDir = dirname(fileURLToPath(import.meta.url));
+  const rootDir = dirname(scriptsDir);
+  const tmp = await mkdtemp(join(tmpdir(), 'happy-stacks-env-cmd-'));
+
+  const storageDir = join(tmp, 'storage');
+  const homeDir = join(tmp, 'home');
+  await mkdir(storageDir, { recursive: true });
+  await mkdir(homeDir, { recursive: true });
+
+  const baseEnv = {
+    ...process.env,
+    HAPPY_STACKS_HOME_DIR: homeDir,
+    HAPPY_STACKS_STORAGE_DIR: storageDir,
+  };
+
+  const res = await runNode([join(rootDir, 'scripts', 'env.mjs')], { cwd: rootDir, env: baseEnv });
+  assert.equal(res.code, 0, `expected exit 0, got ${res.code}\nstdout:\n${res.stdout}\nstderr:\n${res.stderr}`);
+  assert.ok(res.stdout.includes('[env] usage:'), `expected usage output\nstdout:\n${res.stdout}\nstderr:\n${res.stderr}`);
+});
+
+test('happys env list prints keys in text mode', async () => {
+  const scriptsDir = dirname(fileURLToPath(import.meta.url));
+  const rootDir = dirname(scriptsDir);
+  const tmp = await mkdtemp(join(tmpdir(), 'happy-stacks-env-cmd-'));
+
+  const storageDir = join(tmp, 'storage');
+  const homeDir = join(tmp, 'home');
+  const stackName = 'exp1';
+  const envPath = join(storageDir, stackName, 'env');
+  await mkdir(dirname(envPath), { recursive: true });
+  await mkdir(homeDir, { recursive: true });
+  await writeFile(envPath, 'FOO=bar\n', 'utf-8');
+
+  const baseEnv = {
+    ...process.env,
+    HAPPY_STACKS_HOME_DIR: homeDir,
+    HAPPY_STACKS_STORAGE_DIR: storageDir,
+    HAPPY_STACKS_ENV_FILE: envPath,
+  };
+
+  const res = await runNode([join(rootDir, 'scripts', 'env.mjs'), 'list'], { cwd: rootDir, env: baseEnv });
+  assert.equal(res.code, 0, `expected exit 0, got ${res.code}\nstdout:\n${res.stdout}\nstderr:\n${res.stderr}`);
+  assert.ok(res.stdout.includes('FOO=bar'), `expected list output to include FOO=bar\nstdout:\n${res.stdout}`);
+});
+

package/scripts/init.mjs

@@ -1,7 +1,7 @@
 import { existsSync } from 'node:fs';
 import { mkdir, writeFile, readFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
-import { dirname, join } from 'node:path';
+import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { spawnSync } from 'node:child_process';
 import { ensureCanonicalHomeEnvUpdated, ensureHomeEnvUpdated } from './utils/env/config.mjs';
@@ -177,12 +177,15 @@ async function main() {
   process.env.HAPPY_LOCAL_HOME_DIR = process.env.HAPPY_LOCAL_HOME_DIR ?? homeDir;
 
   const workspaceDirRaw = parseArgValue(argv, 'workspace-dir');
-  const workspaceDir = expandHome(firstNonEmpty(
+  const workspaceDirExpanded = expandHome(firstNonEmpty(
     workspaceDirRaw,
     process.env.HAPPY_STACKS_WORKSPACE_DIR,
     process.env.HAPPY_LOCAL_WORKSPACE_DIR,
     join(homeDir, 'workspace'),
   ));
+  // If the user passes a relative --workspace-dir, interpret it as relative to the home dir
+  // (not the current cwd). This keeps setup predictable, especially when invoked via `npx`.
+  const workspaceDir = workspaceDirExpanded.startsWith('/') ? workspaceDirExpanded : resolve(homeDir, workspaceDirExpanded);
   process.env.HAPPY_STACKS_WORKSPACE_DIR = workspaceDir;
   process.env.HAPPY_LOCAL_WORKSPACE_DIR = process.env.HAPPY_LOCAL_WORKSPACE_DIR ?? workspaceDir;
 
@@ -199,7 +202,9 @@ async function main() {
   const storageDirRaw = parseArgValue(argv, 'storage-dir');
   const storageDirOverride = expandHome((storageDirRaw ?? '').trim());
   if (storageDirOverride) {
-    process.env.HAPPY_STACKS_STORAGE_DIR = process.env.HAPPY_STACKS_STORAGE_DIR ?? storageDirOverride;
+    // In sandbox mode, storage dir MUST be isolated and must override any pre-existing env.
+    process.env.HAPPY_STACKS_STORAGE_DIR = isSandboxed() ? storageDirOverride : (process.env.HAPPY_STACKS_STORAGE_DIR ?? storageDirOverride);
+    process.env.HAPPY_LOCAL_STORAGE_DIR = process.env.HAPPY_LOCAL_STORAGE_DIR ?? process.env.HAPPY_STACKS_STORAGE_DIR;
   }
 
   const cliRootDirRaw = parseArgValue(argv, 'cli-root-dir');