@smoothbricks/cli 0.11.15 → 0.11.17

package/src/secrets/commands.ts

@@ -0,0 +1,210 @@
+/**
+ * `smoo secrets` — the operator side of the reconciliation in ./index.ts.
+ *
+ * Values are handed to `gh` over stdin, never through argv (a process list is
+ * world-readable) and never printed. Reading one from the terminal disables
+ * echo, so a pasted key does not end up in a scrollback buffer or a screen
+ * share.
+ */
+
+import { spawn, spawnSync } from 'node:child_process';
+import { getWorkspacePackages } from '../lib/workspace.js';
+import {
+  fetchLocalSecret,
+  localSecretCommandNames,
+  reconcileSecrets,
+  type SecretRow,
+  secretNameMapping,
+  unsatisfiedSecrets,
+  unwiredSecrets,
+  workerSecretNames,
+  workflowSecretNames,
+} from './index.js';
+
+/** Repository secret names GitHub currently holds, or a refusal naming what failed. */
+export function readRepositorySecrets(
+  repo: string | undefined,
+): { ok: true; names: string[] } | { ok: false; reason: string } {
+  const args = ['secret', 'list', '--json', 'name'];
+  if (repo) args.push('--repo', repo);
+  const result = spawnSync('gh', args, { encoding: 'utf8' });
+  if (result.status !== 0) {
+    return {
+      ok: false,
+      reason: `gh ${args.join(' ')} exited ${result.status ?? 'without status'}: ${result.stderr.trim()}`,
+    };
+  }
+  const parsed: unknown = JSON.parse(result.stdout);
+  if (!Array.isArray(parsed)) {
+    return { ok: false, reason: 'gh secret list did not return a list' };
+  }
+  const names: string[] = [];
+  for (const row of parsed) {
+    if (typeof row !== 'object' || row === null || !('name' in row)) continue;
+    // `in` narrows the property to unknown, so the typeof check below is the
+    // only thing that admits it — no assertion about gh's output shape.
+    const name: unknown = row.name;
+    if (typeof name === 'string') names.push(name);
+  }
+  return { ok: true, names: names.sort((left, right) => left.localeCompare(right)) };
+}
+
+/** Write one secret, value over stdin so it never reaches argv. */
+export async function writeRepositorySecret(
+  name: string,
+  value: string,
+  repo: string | undefined,
+): Promise<{ ok: true } | { ok: false; reason: string }> {
+  const args = ['secret', 'set', name];
+  if (repo) args.push('--repo', repo);
+  const child = spawn('gh', args, { stdio: ['pipe', 'inherit', 'inherit'] });
+  child.stdin.end(value);
+  const status = await new Promise<number | null>((resolvePromise) => {
+    child.on('close', (code) => resolvePromise(code));
+  });
+  return status === 0
+    ? { ok: true }
+    : { ok: false, reason: `gh ${args.join(' ')} exited ${status ?? 'without status'}` };
+}
+
+function collectSources(root: string, repositorySecrets: readonly string[]) {
+  const workspaceDirs = getWorkspacePackages(root).map((pkg) => pkg.path);
+  const workerSecrets = workerSecretNames(root, workspaceDirs);
+  const workflowSecrets = workflowSecretNames(root);
+  const localCommands = localSecretCommandNames(root);
+  const envNames = [
+    ...new Set([...Object.values(workerSecrets).flatMap((names) => [...names]), ...workflowSecrets, ...localCommands]),
+  ];
+  return {
+    workerSecrets,
+    workflowSecrets,
+    secretNames: secretNameMapping(root, envNames),
+    localCommands,
+    repositorySecrets,
+  };
+}
+
+function describe(row: SecretRow): string {
+  const where = row.declaredByWorkers.length > 0 ? row.declaredByWorkers.join(', ') : '—';
+  return [
+    row.onRepository ? 'set ' : 'ABSENT',
+    row.name.padEnd(32),
+    row.suppliedByWorkflow ? 'workflow' : '        ',
+    row.fetchableLocally ? 'local' : '     ',
+    where,
+  ].join('  ');
+}
+
+/**
+ * Print every known secret with its sources. Exit code 1 when a workflow
+ * promises a value the repository does not hold — that combination is the one
+ * that fails a deploy, and it fails talking about the value rather than the
+ * missing secret.
+ */
+export function secretsStatus(root: string, options: { repo?: string }): number {
+  const repositorySecrets = readRepositorySecrets(options.repo);
+  if (!repositorySecrets.ok) {
+    console.error(repositorySecrets.reason);
+    return 1;
+  }
+  const rows = reconcileSecrets(collectSources(root, repositorySecrets.names));
+  console.log('state   name                              workflow  local  declared by');
+  for (const row of rows) console.log(describe(row));
+
+  const unsatisfied = unsatisfiedSecrets(rows);
+  const unwired = unwiredSecrets(rows);
+  if (unwired.length > 0) {
+    console.log('');
+    for (const row of unwired) {
+      console.log(
+        `note: ${row.name} is declared by ${row.declaredByWorkers.join(', ')} but no managed workflow passes it; ` +
+          'declare it in smoo.github.deploySecrets to have CI supply it.',
+      );
+    }
+  }
+  if (unsatisfied.length > 0) {
+    console.log('');
+    for (const row of unsatisfied) {
+      console.error(`missing: ${row.name} — a workflow passes secrets.${row.name} and the repository has no value.`);
+      console.error(
+        `         set it with: smoo secrets set ${row.name}${options.repo ? ` --repo ${options.repo}` : ''}`,
+      );
+    }
+    return 1;
+  }
+  return 0;
+}
+
+/** Read a value with echo disabled when stdin is a terminal; otherwise read piped input. */
+async function readSecretValue(prompt: string): Promise<string> {
+  if (!process.stdin.isTTY) {
+    const chunks: Buffer[] = [];
+    for await (const chunk of process.stdin) chunks.push(Buffer.from(chunk));
+    return Buffer.concat(chunks).toString('utf8').replace(/\n$/, '');
+  }
+  process.stderr.write(prompt);
+  process.stdin.setRawMode(true);
+  let value = '';
+  try {
+    for await (const chunk of process.stdin) {
+      const text = Buffer.from(chunk).toString('utf8');
+      if (text === '\r' || text === '\n' || text === '\u0004') break;
+      if (text === '\u0003') throw new Error('cancelled');
+      if (text === '\u007f') {
+        value = value.slice(0, -1);
+        continue;
+      }
+      value += text;
+    }
+  } finally {
+    process.stdin.setRawMode(false);
+    process.stderr.write('\n');
+  }
+  return value;
+}
+
+/** Set one secret from a pasted value. */
+export async function secretsSet(name: string, options: { repo?: string }): Promise<number> {
+  const value = await readSecretValue(`Value for ${name} (not echoed): `);
+  if (value.length === 0) {
+    console.error(`${name}: refusing to set an empty value.`);
+    return 1;
+  }
+  const written = await writeRepositorySecret(name, value, options.repo);
+  if (!written.ok) {
+    console.error(written.reason);
+    return 1;
+  }
+  console.log(`set     ${name}`);
+  return 0;
+}
+
+/**
+ * Push every locally fetchable secret to the repository. Only names
+ * `smoo.secrets` declares a command for: everything else has no source here
+ * and must be pasted with `smoo secrets set`.
+ */
+export async function secretsSync(root: string, options: { repo?: string }): Promise<number> {
+  const names = localSecretCommandNames(root);
+  if (names.length === 0) {
+    console.error('smoo.secrets declares no fetch commands; nothing to sync.');
+    return 1;
+  }
+  let failed = 0;
+  for (const name of names) {
+    const fetched = fetchLocalSecret(root, name);
+    if (!fetched.ok) {
+      console.error(`skip    ${name}: ${fetched.reason}`);
+      failed += 1;
+      continue;
+    }
+    const written = await writeRepositorySecret(name, fetched.value, options.repo);
+    if (!written.ok) {
+      console.error(`fail    ${name}: ${written.reason}`);
+      failed += 1;
+      continue;
+    }
+    console.log(`set     ${name}`);
+  }
+  return failed === 0 ? 0 : 1;
+}

package/src/secrets/index.test.ts

@@ -0,0 +1,92 @@
+import { describe, expect, it } from 'bun:test';
+import { repositorySecretMapping } from '../lib/secret-names.js';
+import { reconcileSecrets, unsatisfiedSecrets, unwiredSecrets } from './index.js';
+
+const sources = {
+  workerSecrets: {
+    'targets/billing': ['STRIPE_PUBLISHABLE_KEY', 'STRIPE_SECRET_KEY'],
+    'targets/mail': ['MAIL_CAPTURE_CONTROL_TOKEN'],
+  },
+  workflowSecrets: ['MAIL_CAPTURE_CONTROL_TOKEN', 'STRIPE_PUBLISHABLE_KEY', 'STRIPE_SECRET_KEY'],
+  localCommands: ['NPM_READ_TOKEN'],
+  secretNames: {
+    STRIPE_PUBLISHABLE_KEY: 'STRIPE_PUBLISHABLE_KEY',
+    STRIPE_SECRET_KEY: 'STRIPE_SECRET_KEY',
+    MAIL_CAPTURE_CONTROL_TOKEN: 'MAIL_CAPTURE_CONTROL_TOKEN',
+    NPM_READ_TOKEN: 'NPM_READ_TOKEN',
+  },
+  repositorySecrets: ['MAIL_CAPTURE_CONTROL_TOKEN', 'NPM_READ_TOKEN'],
+};
+
+describe('secret reconciliation', () => {
+  it('names the secret a workflow passes and the repository does not hold', () => {
+    // A preview stage refuses with `publishable_key_mismatch` when `ci.yml`
+    // passes `secrets.STRIPE_PUBLISHABLE_KEY` and the repository holds no such
+    // secret: the empty value reaches the payment library's validator, which
+    // talks about the key instead of the missing declaration.
+    const unsatisfied = unsatisfiedSecrets(reconcileSecrets(sources)).map((row) => row.name);
+
+    expect(unsatisfied).toEqual(['STRIPE_PUBLISHABLE_KEY', 'STRIPE_SECRET_KEY']);
+  });
+
+  it('keeps "declared but no workflow passes it" separate from "no value"', () => {
+    // The remedies differ: one is `smoo secrets set`, the other is a
+    // smoo.github.deploySecrets entry. Reporting them as one list sends an
+    // operator to the wrong fix.
+    const rows = reconcileSecrets({
+      ...sources,
+      workflowSecrets: ['MAIL_CAPTURE_CONTROL_TOKEN'],
+    });
+
+    expect(unwiredSecrets(rows).map((row) => row.name)).toEqual(['STRIPE_PUBLISHABLE_KEY', 'STRIPE_SECRET_KEY']);
+    expect(unsatisfiedSecrets(rows)).toEqual([]);
+  });
+
+  it('reports a repository secret no source declares, so a stale one is visible', () => {
+    const rows = reconcileSecrets({ ...sources, repositorySecrets: [...sources.repositorySecrets, 'RETIRED_TOKEN'] });
+    const retired = rows.find((row) => row.name === 'RETIRED_TOKEN');
+
+    expect(retired).toEqual({
+      name: 'RETIRED_TOKEN',
+      repositorySecret: 'RETIRED_TOKEN',
+      declaredByWorkers: [],
+      suppliedByWorkflow: false,
+      fetchableLocally: false,
+      onRepository: true,
+    });
+  });
+
+  it('attributes a shared secret to every worker that declares it', () => {
+    const rows = reconcileSecrets({
+      ...sources,
+      workerSecrets: { 'targets/a': ['SHARED'], 'targets/b': ['SHARED'] },
+    });
+
+    expect(rows.find((row) => row.name === 'SHARED')?.declaredByWorkers).toEqual(['targets/a', 'targets/b']);
+  });
+
+  it('reads a reserved env name from its owner-prefixed secret, with no declaration', () => {
+    // GitHub rejects `gh secret set GITHUB_*`, so the value cannot live under
+    // its own name. Operators write the owner-prefixed name by hand in the
+    // workflow; the convention derives exactly that from the repository owner.
+    const rows = reconcileSecrets({
+      workerSecrets: { 'targets/backend': ['GITHUB_CLIENT_SECRET'] },
+      workflowSecrets: ['GITHUB_CLIENT_SECRET'],
+      secretNames: repositorySecretMapping(['GITHUB_CLIENT_SECRET'], 'acme'),
+      localCommands: [],
+      repositorySecrets: ['ACME_GITHUB_CLIENT_SECRET'],
+    });
+
+    expect(rows).toEqual([
+      {
+        name: 'GITHUB_CLIENT_SECRET',
+        repositorySecret: 'ACME_GITHUB_CLIENT_SECRET',
+        declaredByWorkers: ['targets/backend'],
+        suppliedByWorkflow: true,
+        fetchableLocally: false,
+        onRepository: true,
+      },
+    ]);
+    expect(unsatisfiedSecrets(rows)).toEqual([]);
+  });
+});

package/src/secrets/index.ts

@@ -0,0 +1,183 @@
+/**
+ * Reconciles the three places a repository's secrets are described, all of
+ * which smoo already owns:
+ *
+ * 1. **Workers declare names.** `.dev.vars.example` per wrangler project — the
+ *    file `wrangler types --env-file` reads and `prepare-env` prompts from.
+ * 2. **Workflows declare where values come from.** `smoo.github.deploySecrets`
+ *    and `e2eSecrets` map an env name to a repository secret, and the managed
+ *    workflows render exactly those into the job environment.
+ * 3. **A developer shell declares how to fetch one locally.** `smoo.secrets`
+ *    names a command whose stdout is the value.
+ *
+ * Nothing joined them, so a Worker could declare a secret no workflow supplies
+ * and no repository holds. That fails at deploy time, on a stage, with a
+ * fail-closed message about the value rather than about the missing
+ * declaration — the shape that costs an afternoon: a Worker declares
+ * `STRIPE_PUBLISHABLE_KEY`, `ci.yml` passes `secrets.STRIPE_PUBLISHABLE_KEY`,
+ * the repository holds no such secret, and the empty value surfaces as the
+ * payment library's own `publishable_key_mismatch` refusal.
+ */
+
+import { spawnSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { repositoryOwnerFromUrl, repositorySecretMapping } from '../lib/secret-names.js';
+import { readPackageJsonObject, repositoryInfo } from '../lib/workspace.js';
+import { parseDevVarsExample } from '../wrangler/prepare-env.js';
+
+/** Where an env name is described, which repository secret carries it, and whether that exists. */
+export interface SecretRow {
+  name: string;
+  /** The repository secret this env name reads from, by convention or declaration. */
+  repositorySecret: string;
+  /** Wrangler projects whose `.dev.vars.example` declares it. */
+  declaredByWorkers: string[];
+  /** True when a managed workflow renders `secrets.<name>` into a job. */
+  suppliedByWorkflow: boolean;
+  /** True when `smoo.secrets` can fetch it for a developer shell. */
+  fetchableLocally: boolean;
+  /** True when the repository holds a secret of this name. */
+  onRepository: boolean;
+}
+
+export interface SecretSources {
+  /** Worker label -> env names it declares. */
+  workerSecrets: Record<string, readonly string[]>;
+  /** Env names a managed workflow passes into a job. */
+  workflowSecrets: readonly string[];
+  /** Env name -> repository secret, by convention with declared exceptions. */
+  secretNames: Readonly<Record<string, string>>;
+  /** Env names `smoo.secrets` can fetch locally. */
+  localCommands: readonly string[];
+  /** Repository secret names GitHub currently holds. */
+  repositorySecrets: readonly string[];
+}
+
+/**
+ * One row per name known to any source, sorted, so a reader sees the whole
+ * picture rather than one source's view of it.
+ */
+export function reconcileSecrets(sources: SecretSources): SecretRow[] {
+  const declaredByAnyWorker: string[] = Object.values(sources.workerSecrets).flatMap((names) => [...names]);
+  const names = new Set<string>([...declaredByAnyWorker, ...sources.workflowSecrets, ...sources.localCommands]);
+  // A repository secret that already carries a known env name is that name's
+  // row, not a row of its own: listing ACME_GITHUB_CLIENT_SECRET beside
+  // GITHUB_CLIENT_SECRET would report one value as two secrets, one of them
+  // permanently "declared by nothing".
+  const carriesKnownEnvName = new Set(
+    names.size > 0 ? [...names].map((name) => sources.secretNames[name] ?? name) : [],
+  );
+  for (const secret of sources.repositorySecrets) {
+    if (!carriesKnownEnvName.has(secret)) names.add(secret);
+  }
+  return [...names]
+    .sort((left, right) => left.localeCompare(right))
+    .map((name) => ({
+      name,
+      repositorySecret: sources.secretNames[name] ?? name,
+      declaredByWorkers: Object.entries(sources.workerSecrets)
+        .filter(([, declared]) => declared.includes(name))
+        .map(([label]) => label)
+        .sort((left, right) => left.localeCompare(right)),
+      suppliedByWorkflow: sources.workflowSecrets.includes(name),
+      fetchableLocally: sources.localCommands.includes(name),
+      onRepository: sources.repositorySecrets.includes(sources.secretNames[name] ?? name),
+    }));
+}
+
+/**
+ * The rows a CI deploy cannot satisfy: a Worker declares the name, a workflow
+ * promises to pass it, and the repository has no value to pass. Reported
+ * separately from "declared but not wired into any workflow", because the
+ * remedies differ — set a secret, versus declare it in `smoo.github`.
+ */
+export function unsatisfiedSecrets(rows: readonly SecretRow[]): SecretRow[] {
+  return rows.filter((row) => row.suppliedByWorkflow && !row.onRepository);
+}
+
+/** Worker-declared names no managed workflow passes: a CI deploy will run without them. */
+export function unwiredSecrets(rows: readonly SecretRow[]): SecretRow[] {
+  return rows.filter((row) => row.declaredByWorkers.length > 0 && !row.suppliedByWorkflow);
+}
+
+/** Env names the managed workflows pass into a job, from the declarations that render them. */
+export function workflowSecretNames(root: string): string[] {
+  const manifest = readPackageJsonObject(join(root, 'package.json'));
+  const smoo = manifest?.smoo;
+  const github = smoo?.github;
+  const names = new Set<string>([
+    ...Object.keys(github?.deploySecrets ?? {}),
+    ...Object.keys(github?.e2eSecrets ?? {}),
+  ]);
+  if (smoo?.remoteCache?.tokenSecret) names.add(smoo.remoteCache.tokenSecret);
+  for (const origin of github?.cargoCredentials?.gitOrigins ?? []) {
+    if (origin.tokenEnv) names.add(origin.tokenEnv);
+  }
+  for (const source of github?.sourceCheckouts ?? []) {
+    if (source.tokenEnv) names.add(source.tokenEnv);
+  }
+  if (smoo?.privateNpm?.readTokenEnv) names.add(smoo.privateNpm.readTokenEnv);
+  if (smoo?.privateNpm?.publishTokenEnv) names.add(smoo.privateNpm.publishTokenEnv);
+  return [...names].sort((left, right) => left.localeCompare(right));
+}
+
+/**
+ * Env name -> repository secret for every name in play, following the naming
+ * convention and honouring the declared exceptions a repository still needs.
+ */
+export function secretNameMapping(root: string, envNames: readonly string[]): Record<string, string> {
+  const manifest = readPackageJsonObject(join(root, 'package.json'));
+  const declared = { ...(manifest?.smoo?.github?.deploySecrets ?? {}), ...(manifest?.smoo?.github?.e2eSecrets ?? {}) };
+  const repository = manifest ? repositoryInfo(manifest) : null;
+  const owner = repository ? (repositoryOwnerFromUrl(repository.url) ?? '') : '';
+  return repositorySecretMapping(envNames, owner, declared);
+}
+
+/** Every wrangler project's declared secret names, keyed by the project directory. */
+export function workerSecretNames(root: string, workspaceDirs: readonly string[]): Record<string, string[]> {
+  const byWorker: Record<string, string[]> = {};
+  for (const dir of workspaceDirs) {
+    const examplePath = join(root, dir, '.dev.vars.example');
+    if (!existsSync(examplePath)) continue;
+    const names = parseDevVarsExample(readFileSync(examplePath, 'utf8'));
+    if (names.length > 0) byWorker[dir] = names;
+  }
+  return byWorker;
+}
+
+/** Names `smoo.secrets` declares a fetch command for. */
+export function localSecretCommandNames(root: string): string[] {
+  const manifest = readPackageJsonObject(join(root, 'package.json'));
+  return Object.keys(manifest?.smoo?.secrets ?? {}).sort((left, right) => left.localeCompare(right));
+}
+
+/**
+ * Resolve one declared secret through its command. The value is returned, never
+ * logged: callers hand it to `gh secret set` over stdin.
+ */
+export function fetchLocalSecret(
+  root: string,
+  name: string,
+): { ok: true; value: string } | { ok: false; reason: string } {
+  const manifest = readPackageJsonObject(join(root, 'package.json'));
+  const declared = manifest?.smoo?.secrets?.[name];
+  if (!declared) {
+    return { ok: false, reason: `smoo.secrets declares no command for ${name}` };
+  }
+  const [command, ...args] = declared.command;
+  const result = spawnSync(command, args, { encoding: 'utf8' });
+  if (result.status !== 0) {
+    // Name the command, never its output: a failing secret fetch prints
+    // credentials often enough that it is worth refusing to.
+    return {
+      ok: false,
+      reason: `${name}: \`${declared.command.join(' ')}\` exited ${result.status ?? 'without status'}`,
+    };
+  }
+  const value = result.stdout.replace(/\n$/, '');
+  if (value.length === 0) {
+    return { ok: false, reason: `${name}: \`${declared.command.join(' ')}\` produced no value` };
+  }
+  return { ok: true, value };
+}