@auraindustry/aurajs 0.0.6 → 0.1.0

package/src/publish-command.mjs

@@ -0,0 +1,195 @@
+import { spawn } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+
+import { preparePublishPackageSurface } from './external-package-surface.mjs';
+import {
+  PACKAGE_INTEGRITY_PUBLISH_FILES,
+  writeSignedPackageIntegrityArtifacts,
+} from './package-integrity.mjs';
+import { resolvePublishEnvExampleSurface } from './publish-env-example.mjs';
+import { validatePublishProject } from './publish-validation.mjs';
+
+export function isNpmPublishLifecycleInvocation(env = process.env) {
+  return env.npm_lifecycle_event === 'publish' && env.npm_command === 'publish';
+}
+
+export function hasOption(commandArgs, optionName) {
+  return commandArgs.some((arg) => arg === optionName || arg.startsWith(`${optionName}=`));
+}
+
+export function readProjectPackage(projectRoot = process.cwd()) {
+  const packagePath = resolve(projectRoot, 'package.json');
+  if (!existsSync(packagePath)) {
+    throw new Error('aura publish requires a package.json in the current project root.');
+  }
+
+  let projectPackage;
+  try {
+    projectPackage = JSON.parse(readFileSync(packagePath, 'utf8'));
+  } catch (error) {
+    throw new Error(`Failed to read package.json for aura publish: ${error.message}`);
+  }
+
+  const packageName = typeof projectPackage?.name === 'string' && projectPackage.name.trim().length > 0
+    ? projectPackage.name.trim()
+    : null;
+  if (!packageName) {
+    throw new Error('aura publish requires package.json -> name to be set.');
+  }
+
+  return {
+    packagePath,
+    projectPackage,
+    packageName,
+  };
+}
+
+export function buildPublishArgs(commandArgs, { packageName } = {}) {
+  const publishArgs = ['publish', ...commandArgs];
+  if (String(packageName || '').startsWith('@') && !hasOption(commandArgs, '--access')) {
+    publishArgs.push('--access', 'public');
+  }
+  return publishArgs;
+}
+
+function resolveNpmCommand() {
+  return process.platform === 'win32' ? 'npm.cmd' : 'npm';
+}
+
+function pipeChildStream(stream, target) {
+  if (!stream || !target) return;
+  stream.on('data', (chunk) => {
+    target.write(chunk);
+  });
+}
+
+function spawnPublish(commandArgs, { projectRoot, env, stdout, stderr }) {
+  return new Promise((resolveRun, rejectRun) => {
+    const child = spawn(resolveNpmCommand(), commandArgs, {
+      cwd: projectRoot,
+      stdio: ['ignore', 'pipe', 'pipe'],
+      env,
+    });
+
+    pipeChildStream(child.stdout, stdout);
+    pipeChildStream(child.stderr, stderr);
+
+    child.on('error', (error) => {
+      rejectRun(error);
+    });
+
+    child.on('close', (code, signal) => {
+      if ((code ?? 1) === 0) {
+        resolveRun({
+          ok: true,
+          code: 0,
+          signal: signal ?? null,
+        });
+        return;
+      }
+
+      if (signal) {
+        rejectRun(new Error(`npm publish exited by signal ${signal}.`));
+        return;
+      }
+
+      rejectRun(new Error(`npm publish exited with code ${code ?? 1}.`));
+    });
+  });
+}
+
+export async function runPublishCommand(
+  commandArgs,
+  {
+    projectRoot = process.cwd(),
+    env = process.env,
+    stdout = process.stdout,
+    stderr = process.stderr,
+    validateProject = validatePublishProject,
+  } = {},
+) {
+  if (isNpmPublishLifecycleInvocation(env)) {
+    const { packageName } = readProjectPackage(projectRoot);
+    stdout?.write('\n  aura publish: publish lifecycle detected, skipping wrapper recursion.\n\n');
+    return {
+      ok: true,
+      skipped: true,
+      reasonCode: 'publish_lifecycle_recursion_guard',
+      packageName,
+      publishArgs: [],
+    };
+  }
+
+  let validation;
+  try {
+    validation = await validateProject({
+      projectRoot,
+      env,
+      stdout,
+      stderr,
+    });
+  } catch (error) {
+    if (error?.reasonCode === 'publish_asset_threshold_exceeded') {
+      const assetBytes = Number.isFinite(error?.details?.assetBytes) ? error.details.assetBytes : null;
+      const thresholdBytes = Number.isFinite(error?.details?.thresholdBytes) ? error.details.thresholdBytes : null;
+      if (assetBytes !== null && thresholdBytes !== null) {
+        stdout?.write(`  Asset payload: ${assetBytes} bytes (threshold ${thresholdBytes})\n`);
+      }
+      stdout?.write('  Next step: upload the heavy assets to a public HTTPS host like Cloudflare R2 or S3, generate the external asset config, then retry publish.\n');
+    }
+    if (error?.reportPath) {
+      stdout?.write(`  Validation report: ${error.reportPath}\n\n`);
+    }
+    throw error;
+  }
+
+  const packageName = validation.packageName;
+  const { projectPackage } = readProjectPackage(projectRoot);
+  const publishArgs = buildPublishArgs(commandArgs, { packageName });
+  const dryRun = hasOption(commandArgs, '--dry-run');
+  const envExampleSurface = resolvePublishEnvExampleSurface({ projectRoot });
+  const packageSurface = preparePublishPackageSurface({
+    projectRoot,
+    projectPackage,
+    assetDir: validation?.report?.validation?.pack?.assetDir || 'assets',
+    assetPolicy: validation?.report?.validation?.assets || null,
+    generatedFilePaths: PACKAGE_INTEGRITY_PUBLISH_FILES,
+    generatedFiles: envExampleSurface.generatedFiles,
+    excludedFilePaths: envExampleSurface.excludedFilePaths,
+  });
+  writeSignedPackageIntegrityArtifacts({
+    packageRoot: packageSurface.publishRoot,
+    signerProjectRoot: projectRoot,
+    buildMetadata: validation?.report?.validation?.build || null,
+  });
+  stdout?.write(`\n  aura publish: ${dryRun ? 'dry-run' : 'npm-first publish'}\n`);
+  stdout?.write(`  Package: ${packageName}\n`);
+  stdout?.write(`  Validation report: ${validation.reportPath}\n`);
+  if (Number.isFinite(validation?.report?.validation?.assets?.assetBytes)) {
+    const assets = validation.report.validation.assets;
+    stdout?.write(`  Asset payload: ${assets.assetBytes} bytes (threshold ${assets.thresholdBytes})\n`);
+  }
+  stdout?.write(`  Package surface: ${packageSurface.mode}\n`);
+  stdout?.write(`  Command: npm ${publishArgs.join(' ')}\n\n`);
+
+  try {
+    await spawnPublish(publishArgs, {
+      projectRoot: packageSurface.publishRoot,
+      env,
+      stdout,
+      stderr,
+    });
+  } finally {
+    packageSurface.cleanup();
+  }
+
+  return {
+    ok: true,
+    skipped: false,
+    reasonCode: dryRun ? 'publish_dry_run_ok' : 'publish_ok',
+    packageName,
+    reportPath: validation.reportPath,
+    publishArgs,
+  };
+}

package/src/publish-env-example.mjs

@@ -0,0 +1,83 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+
+export const PUBLISH_SOURCE_ENV_PATH = '.env';
+export const PUBLISH_ENV_EXAMPLE_PATH = '.env.example';
+
+const ENV_ASSIGNMENT_PATTERN = /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=/;
+
+function collectEnvKeys(source) {
+  const keys = [];
+  const seen = new Set();
+
+  for (const rawLine of String(source || '').replace(/^\uFEFF/, '').split(/\r?\n/)) {
+    const match = rawLine.match(ENV_ASSIGNMENT_PATTERN);
+    if (!match) {
+      continue;
+    }
+
+    const key = match[1];
+    if (seen.has(key)) {
+      continue;
+    }
+
+    seen.add(key);
+    keys.push(key);
+  }
+
+  return keys;
+}
+
+export function buildPublishEnvExampleContents(source) {
+  const keys = collectEnvKeys(source);
+  const lines = [
+    '# Auto-generated by aura publish from .env.',
+    '# Values are intentionally blank.',
+  ];
+
+  if (keys.length > 0) {
+    lines.push('');
+    for (const key of keys) {
+      lines.push(`${key}=`);
+    }
+  }
+
+  return `${lines.join('\n')}\n`;
+}
+
+export function resolvePublishEnvExampleSurface({ projectRoot = process.cwd() } = {}) {
+  const sourceEnvPath = resolve(projectRoot, PUBLISH_SOURCE_ENV_PATH);
+  if (!existsSync(sourceEnvPath)) {
+    return {
+      generatedFiles: [],
+      excludedFilePaths: [],
+      metadata: {
+        sourceEnvPath: PUBLISH_SOURCE_ENV_PATH,
+        sourceEnvPresent: false,
+        generatedExample: false,
+        generatedExamplePath: null,
+        variableCount: 0,
+        variableNames: [],
+      },
+    };
+  }
+
+  const source = readFileSync(sourceEnvPath, 'utf8');
+  const variableNames = collectEnvKeys(source);
+
+  return {
+    generatedFiles: [{
+      path: PUBLISH_ENV_EXAMPLE_PATH,
+      contents: buildPublishEnvExampleContents(source),
+    }],
+    excludedFilePaths: [PUBLISH_SOURCE_ENV_PATH],
+    metadata: {
+      sourceEnvPath: PUBLISH_SOURCE_ENV_PATH,
+      sourceEnvPresent: true,
+      generatedExample: true,
+      generatedExamplePath: PUBLISH_ENV_EXAMPLE_PATH,
+      variableCount: variableNames.length,
+      variableNames,
+    },
+  };
+}