browser-commander 0.2.0

package/scripts/publish-to-npm.mjs

@@ -0,0 +1,126 @@
+#!/usr/bin/env node
+
+/**
+ * Publish to npm using OIDC trusted publishing
+ * Usage: node scripts/publish-to-npm.mjs [--should-pull]
+ *   should_pull: Optional flag to pull latest changes before publishing (for release job)
+ *
+ * Uses link-foundation libraries:
+ * - use-m: Dynamic package loading without package.json dependencies
+ * - command-stream: Modern shell command execution with streaming support
+ * - lino-arguments: Unified configuration from CLI args, env vars, and .lenv files
+ */
+
+import { readFileSync, appendFileSync } from 'fs';
+
+const PACKAGE_NAME = 'browser-commander';
+
+// Load use-m dynamically
+const { use } = eval(
+  await (await fetch('https://unpkg.com/use-m/use.js')).text()
+);
+
+// Import link-foundation libraries
+const { $ } = await use('command-stream');
+const { makeConfig } = await use('lino-arguments');
+
+// Parse CLI arguments using lino-arguments
+const config = makeConfig({
+  yargs: ({ yargs, getenv }) =>
+    yargs.option('should-pull', {
+      type: 'boolean',
+      default: getenv('SHOULD_PULL', false),
+      describe: 'Pull latest changes before publishing',
+    }),
+});
+
+const { shouldPull } = config;
+const MAX_RETRIES = 3;
+const RETRY_DELAY = 10000; // 10 seconds
+
+/**
+ * Sleep for specified milliseconds
+ * @param {number} ms
+ */
+function sleep(ms) {
+  return new Promise((resolve) => globalThis.setTimeout(resolve, ms));
+}
+
+/**
+ * Append to GitHub Actions output file
+ * @param {string} key
+ * @param {string} value
+ */
+function setOutput(key, value) {
+  const outputFile = process.env.GITHUB_OUTPUT;
+  if (outputFile) {
+    appendFileSync(outputFile, `${key}=${value}\n`);
+  }
+}
+
+async function main() {
+  try {
+    if (shouldPull) {
+      // Pull the latest changes we just pushed
+      await $`git pull origin main`;
+    }
+
+    // Get current version
+    const packageJson = JSON.parse(readFileSync('./package.json', 'utf8'));
+    const currentVersion = packageJson.version;
+    console.log(`Current version to publish: ${currentVersion}`);
+
+    // Check if this version is already published on npm
+    console.log(
+      `Checking if version ${currentVersion} is already published...`
+    );
+    const checkResult =
+      await $`npm view "${PACKAGE_NAME}@${currentVersion}" version`.run({
+        capture: true,
+      });
+
+    // command-stream returns { code: 0 } on success, { code: 1 } on failure (e.g., E404)
+    // Exit code 0 means version exists, non-zero means version not found
+    if (checkResult.code === 0) {
+      console.log(`Version ${currentVersion} is already published to npm`);
+      setOutput('published', 'true');
+      setOutput('published_version', currentVersion);
+      setOutput('already_published', 'true');
+      return;
+    } else {
+      // Version not found on npm (E404), proceed with publish
+      console.log(
+        `Version ${currentVersion} not found on npm, proceeding with publish...`
+      );
+    }
+
+    // Publish to npm using OIDC trusted publishing with retry logic
+    for (let i = 1; i <= MAX_RETRIES; i++) {
+      console.log(`Publish attempt ${i} of ${MAX_RETRIES}...`);
+      try {
+        await $`npm run changeset:publish`;
+        setOutput('published', 'true');
+        setOutput('published_version', currentVersion);
+        console.log(
+          `\u2705 Published ${PACKAGE_NAME}@${currentVersion} to npm`
+        );
+        return;
+      } catch (error) {
+        if (i < MAX_RETRIES) {
+          console.log(
+            `Publish failed: ${error.message}, waiting ${RETRY_DELAY / 1000}s before retry...`
+          );
+          await sleep(RETRY_DELAY);
+        }
+      }
+    }
+
+    console.error(`\u274C Failed to publish after ${MAX_RETRIES} attempts`);
+    process.exit(1);
+  } catch (error) {
+    console.error('Error:', error.message);
+    process.exit(1);
+  }
+}
+
+main();

package/scripts/setup-npm.mjs

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+
+/**
+ * Update npm for OIDC trusted publishing
+ * npm trusted publishing requires npm >= 11.5.1
+ * Node.js 20.x ships with npm 10.x, so we need to update
+ *
+ * Uses link-foundation libraries:
+ * - use-m: Dynamic package loading without package.json dependencies
+ * - command-stream: Modern shell command execution with streaming support
+ */
+
+// Load use-m dynamically
+const { use } = eval(
+  await (await fetch('https://unpkg.com/use-m/use.js')).text()
+);
+
+// Import command-stream for shell command execution
+const { $ } = await use('command-stream');
+
+try {
+  // Get current npm version
+  const currentResult = await $`npm --version`.run({ capture: true });
+  const currentVersion = currentResult.stdout.trim();
+  console.log(`Current npm version: ${currentVersion}`);
+
+  // Update npm to latest
+  await $`npm install -g npm@latest`;
+
+  // Get updated npm version
+  const updatedResult = await $`npm --version`.run({ capture: true });
+  const updatedVersion = updatedResult.stdout.trim();
+  console.log(`Updated npm version: ${updatedVersion}`);
+} catch (error) {
+  console.error('Error updating npm:', error.message);
+  process.exit(1);
+}

package/scripts/validate-changeset.mjs

@@ -0,0 +1,262 @@
+#!/usr/bin/env node
+
+/**
+ * Validate changeset for CI - ensures exactly one valid changeset is added by the PR
+ *
+ * Key behavior:
+ * - Only checks changeset files ADDED by the current PR (not pre-existing ones)
+ * - Uses git diff to compare PR head against base branch
+ * - Validates that the PR adds exactly one changeset with proper format
+ * - Falls back to checking all changesets for local development
+ */
+
+import { execSync } from 'child_process';
+import { readFileSync, readdirSync, existsSync } from 'fs';
+import { join } from 'path';
+
+const PACKAGE_NAME = 'browser-commander';
+const CHANGESET_DIR = '.changeset';
+
+/**
+ * Ensure a git commit is available locally, fetching if necessary
+ * @param {string} sha The commit SHA to check
+ */
+function ensureCommitAvailable(sha) {
+  try {
+    execSync(`git cat-file -e ${sha}`, { stdio: 'ignore' });
+  } catch {
+    console.log('Base commit not available locally, attempting fetch...');
+    try {
+      execSync(`git fetch origin ${sha}`, { stdio: 'inherit' });
+    } catch {
+      execSync(`git fetch origin`, { stdio: 'inherit' });
+    }
+  }
+}
+
+/**
+ * Parse git diff output and extract added changeset files
+ * @param {string} diffOutput Output from git diff --name-status
+ * @returns {string[]} Array of added changeset file names
+ */
+function parseAddedChangesets(diffOutput) {
+  const addedChangesets = [];
+  for (const line of diffOutput.trim().split('\n')) {
+    if (!line) {
+      continue;
+    }
+    const [status, filePath] = line.split('\t');
+    if (
+      status === 'A' &&
+      filePath.startsWith(`${CHANGESET_DIR}/`) &&
+      filePath.endsWith('.md') &&
+      !filePath.endsWith('README.md')
+    ) {
+      addedChangesets.push(filePath.replace(`${CHANGESET_DIR}/`, ''));
+    }
+  }
+  return addedChangesets;
+}
+
+/**
+ * Try to get changesets using explicit SHA comparison
+ * @param {string} baseSha Base commit SHA
+ * @param {string} headSha Head commit SHA
+ * @returns {string[] | null} Array of changeset files or null if failed
+ */
+function tryExplicitShaComparison(baseSha, headSha) {
+  console.log(`Comparing ${baseSha}...${headSha}`);
+  try {
+    ensureCommitAvailable(baseSha);
+    const diffOutput = execSync(
+      `git diff --name-status ${baseSha} ${headSha}`,
+      { encoding: 'utf-8' }
+    );
+    return parseAddedChangesets(diffOutput);
+  } catch (error) {
+    console.log(`Git diff with explicit SHAs failed: ${error.message}`);
+    return null;
+  }
+}
+
+/**
+ * Try to get changesets using base branch comparison
+ * @param {string} prBase Base branch name
+ * @returns {string[] | null} Array of changeset files or null if failed
+ */
+function tryBaseBranchComparison(prBase) {
+  console.log(`Comparing against base branch: ${prBase}`);
+  try {
+    try {
+      execSync(`git fetch origin ${prBase}`, { stdio: 'inherit' });
+    } catch {
+      // Ignore fetch errors, we might already have it
+    }
+    const diffOutput = execSync(
+      `git diff --name-status origin/${prBase}...HEAD`,
+      { encoding: 'utf-8' }
+    );
+    return parseAddedChangesets(diffOutput);
+  } catch (error) {
+    console.log(`Git diff with base ref failed: ${error.message}`);
+    return null;
+  }
+}
+
+/**
+ * Fallback: get all changesets in directory
+ * @returns {string[]} Array of all changeset file names
+ */
+function getAllChangesets() {
+  console.log(
+    'Warning: Could not determine PR diff, checking all changesets in directory'
+  );
+  if (!existsSync(CHANGESET_DIR)) {
+    return [];
+  }
+  return readdirSync(CHANGESET_DIR).filter(
+    (file) => file.endsWith('.md') && file !== 'README.md'
+  );
+}
+
+/**
+ * Get changeset files added in the current PR using git diff
+ * @returns {string[]} Array of added changeset file names
+ */
+function getAddedChangesetFiles() {
+  const baseSha = process.env.GITHUB_BASE_SHA || process.env.BASE_SHA;
+  const headSha = process.env.GITHUB_HEAD_SHA || process.env.HEAD_SHA;
+
+  // Try explicit SHAs first
+  if (baseSha && headSha) {
+    const result = tryExplicitShaComparison(baseSha, headSha);
+    if (result !== null) {
+      return result;
+    }
+  }
+
+  // Try base branch comparison
+  const prBase = process.env.GITHUB_BASE_REF;
+  if (prBase) {
+    const result = tryBaseBranchComparison(prBase);
+    if (result !== null) {
+      return result;
+    }
+  }
+
+  // Fallback to checking all changesets
+  return getAllChangesets();
+}
+
+/**
+ * Validate a single changeset file
+ * @param {string} filePath Full path to the changeset file
+ * @returns {{valid: boolean, type?: string, description?: string, error?: string}}
+ */
+function validateChangesetFile(filePath) {
+  try {
+    const content = readFileSync(filePath, 'utf-8');
+
+    // Check if changeset has a valid type (major, minor, or patch)
+    const versionTypeRegex = new RegExp(
+      `^['"]${PACKAGE_NAME.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}['"]:\\s+(major|minor|patch)`,
+      'm'
+    );
+    const versionTypeMatch = content.match(versionTypeRegex);
+
+    if (!versionTypeMatch) {
+      return {
+        valid: false,
+        error: `Changeset must specify a version type: major, minor, or patch\nExpected format:\n---\n'${PACKAGE_NAME}': patch\n---\n\nYour description here`,
+      };
+    }
+
+    // Extract description (everything after the closing ---) and check it's not empty
+    const parts = content.split('---');
+    if (parts.length < 3) {
+      return {
+        valid: false,
+        error:
+          "Changeset must include a description of the changes (after the closing '---')",
+      };
+    }
+
+    const description = parts.slice(2).join('---').trim();
+    if (!description) {
+      return {
+        valid: false,
+        error: 'Changeset must include a non-empty description of the changes',
+      };
+    }
+
+    return {
+      valid: true,
+      type: versionTypeMatch[1],
+      description,
+    };
+  } catch (error) {
+    return {
+      valid: false,
+      error: `Failed to read changeset file: ${error.message}`,
+    };
+  }
+}
+
+try {
+  console.log('Validating changesets added by this PR...');
+
+  // Get changeset files added in this PR
+  const addedChangesetFiles = getAddedChangesetFiles();
+  const changesetCount = addedChangesetFiles.length;
+
+  console.log(`Found ${changesetCount} changeset file(s) added by this PR`);
+  if (changesetCount > 0) {
+    console.log('Added changesets:');
+    addedChangesetFiles.forEach((file) => console.log(`  - ${file}`));
+  }
+
+  // Ensure exactly one changeset file was added
+  if (changesetCount === 0) {
+    console.error(
+      "::error::No changeset found in this PR. Please add a changeset by running 'npm run changeset' and commit the result."
+    );
+    process.exit(1);
+  } else if (changesetCount > 1) {
+    console.error(
+      `::error::Multiple changesets found in this PR (${changesetCount}). Each PR should add exactly ONE changeset.`
+    );
+    console.error('::error::Found changeset files added by this PR:');
+    addedChangesetFiles.forEach((file) => console.error(`  ${file}`));
+    console.error(
+      '\n::error::Please combine these into a single changeset or remove the extras.'
+    );
+    process.exit(1);
+  }
+
+  // Validate the single changeset file
+  const changesetFile = join(CHANGESET_DIR, addedChangesetFiles[0]);
+  console.log(`Validating changeset: ${changesetFile}`);
+
+  const validation = validateChangesetFile(changesetFile);
+
+  if (!validation.valid) {
+    console.error(`::error::${validation.error}`);
+    console.error(`\nFile content of ${changesetFile}:`);
+    try {
+      console.error(readFileSync(changesetFile, 'utf-8'));
+    } catch {
+      console.error('(could not read file)');
+    }
+    process.exit(1);
+  }
+
+  console.log('Changeset validation passed');
+  console.log(`   Type: ${validation.type}`);
+  console.log(`   Description: ${validation.description}`);
+} catch (error) {
+  console.error('Error during changeset validation:', error.message);
+  if (process.env.DEBUG) {
+    console.error('Stack trace:', error.stack);
+  }
+  process.exit(1);
+}

package/scripts/version-and-commit.mjs

@@ -0,0 +1,237 @@
+#!/usr/bin/env node
+
+/**
+ * Version packages and commit to main
+ * Usage: node scripts/version-and-commit.mjs --mode <changeset|instant> [--bump-type <type>] [--description <desc>]
+ *   changeset: Run changeset version
+ *   instant: Run instant version bump with bump_type (patch|minor|major) and optional description
+ *
+ * Uses link-foundation libraries:
+ * - use-m: Dynamic package loading without package.json dependencies
+ * - command-stream: Modern shell command execution with streaming support
+ * - lino-arguments: Unified configuration from CLI args, env vars, and .lenv files
+ */
+
+import { readFileSync, appendFileSync, readdirSync } from 'fs';
+
+// Load use-m dynamically
+const { use } = eval(
+  await (await fetch('https://unpkg.com/use-m/use.js')).text()
+);
+
+// Import link-foundation libraries
+const { $ } = await use('command-stream');
+const { makeConfig } = await use('lino-arguments');
+
+// Parse CLI arguments using lino-arguments
+const config = makeConfig({
+  yargs: ({ yargs, getenv }) =>
+    yargs
+      .option('mode', {
+        type: 'string',
+        default: getenv('MODE', 'changeset'),
+        describe: 'Version mode: changeset or instant',
+        choices: ['changeset', 'instant'],
+      })
+      .option('bump-type', {
+        type: 'string',
+        default: getenv('BUMP_TYPE', ''),
+        describe: 'Version bump type for instant mode: major, minor, or patch',
+      })
+      .option('description', {
+        type: 'string',
+        default: getenv('DESCRIPTION', ''),
+        describe: 'Description for instant version bump',
+      }),
+});
+
+const { mode, bumpType, description } = config;
+
+// Debug: Log parsed configuration
+console.log('Parsed configuration:', {
+  mode,
+  bumpType,
+  description: description || '(none)',
+});
+
+// Detect if positional arguments were used (common mistake)
+const args = process.argv.slice(2);
+if (args.length > 0 && !args[0].startsWith('--')) {
+  console.error('Error: Positional arguments detected!');
+  console.error('Command line arguments:', args);
+  console.error('');
+  console.error(
+    'This script requires named arguments (--mode, --bump-type, --description).'
+  );
+  console.error('Usage:');
+  console.error('  Changeset mode:');
+  console.error('    node scripts/version-and-commit.mjs --mode changeset');
+  console.error('  Instant mode:');
+  console.error(
+    '    node scripts/version-and-commit.mjs --mode instant --bump-type <major|minor|patch> [--description <desc>]'
+  );
+  console.error('');
+  console.error('Examples:');
+  console.error(
+    '  node scripts/version-and-commit.mjs --mode instant --bump-type patch --description "Fix bug"'
+  );
+  console.error('  node scripts/version-and-commit.mjs --mode changeset');
+  process.exit(1);
+}
+
+// Validation: Ensure mode is set correctly
+if (mode !== 'changeset' && mode !== 'instant') {
+  console.error(`Invalid mode: "${mode}". Expected "changeset" or "instant".`);
+  console.error('Command line arguments:', process.argv.slice(2));
+  process.exit(1);
+}
+
+// Validation: Ensure bump type is provided for instant mode
+if (mode === 'instant' && !bumpType) {
+  console.error('Error: --bump-type is required for instant mode');
+  console.error(
+    'Usage: node scripts/version-and-commit.mjs --mode instant --bump-type <major|minor|patch> [--description <desc>]'
+  );
+  process.exit(1);
+}
+
+/**
+ * Append to GitHub Actions output file
+ * @param {string} key
+ * @param {string} value
+ */
+function setOutput(key, value) {
+  const outputFile = process.env.GITHUB_OUTPUT;
+  if (outputFile) {
+    appendFileSync(outputFile, `${key}=${value}\n`);
+  }
+}
+
+/**
+ * Count changeset files (excluding README.md)
+ */
+function countChangesets() {
+  try {
+    const changesetDir = '.changeset';
+    const files = readdirSync(changesetDir);
+    return files.filter((f) => f.endsWith('.md') && f !== 'README.md').length;
+  } catch {
+    return 0;
+  }
+}
+
+/**
+ * Get package version
+ * @param {string} source - 'local' or 'remote'
+ */
+async function getVersion(source = 'local') {
+  if (source === 'remote') {
+    const result = await $`git show origin/main:package.json`.run({
+      capture: true,
+    });
+    return JSON.parse(result.stdout).version;
+  }
+  return JSON.parse(readFileSync('./package.json', 'utf8')).version;
+}
+
+async function main() {
+  try {
+    // Configure git
+    await $`git config user.name "github-actions[bot]"`;
+    await $`git config user.email "github-actions[bot]@users.noreply.github.com"`;
+
+    // Check if remote main has advanced (handles re-runs after partial success)
+    console.log('Checking for remote changes...');
+    await $`git fetch origin main`;
+
+    const localHeadResult = await $`git rev-parse HEAD`.run({ capture: true });
+    const localHead = localHeadResult.stdout.trim();
+
+    const remoteHeadResult = await $`git rev-parse origin/main`.run({
+      capture: true,
+    });
+    const remoteHead = remoteHeadResult.stdout.trim();
+
+    if (localHead !== remoteHead) {
+      console.log(
+        `Remote main has advanced (local: ${localHead}, remote: ${remoteHead})`
+      );
+      console.log('This may indicate a previous attempt partially succeeded.');
+
+      // Check if the remote version is already the expected bump
+      const remoteVersion = await getVersion('remote');
+      console.log(`Remote version: ${remoteVersion}`);
+
+      // Check if there are changesets to process
+      const changesetCount = countChangesets();
+
+      if (changesetCount === 0) {
+        console.log('No changesets to process and remote has advanced.');
+        console.log(
+          'Assuming version bump was already completed in a previous attempt.'
+        );
+        setOutput('version_committed', 'false');
+        setOutput('already_released', 'true');
+        setOutput('new_version', remoteVersion);
+        return;
+      } else {
+        console.log('Rebasing on remote main to incorporate changes...');
+        await $`git rebase origin/main`;
+      }
+    }
+
+    // Get current version before bump
+    const oldVersion = await getVersion();
+    console.log(`Current version: ${oldVersion}`);
+
+    if (mode === 'instant') {
+      console.log('Running instant version bump...');
+      // Run instant version bump script
+      // Rely on command-stream's auto-quoting for proper argument handling
+      if (description) {
+        await $`node scripts/instant-version-bump.mjs --bump-type ${bumpType} --description ${description}`;
+      } else {
+        await $`node scripts/instant-version-bump.mjs --bump-type ${bumpType}`;
+      }
+    } else {
+      console.log('Running changeset version...');
+      // Run changeset version to bump versions and update CHANGELOG
+      await $`npm run changeset:version`;
+    }
+
+    // Get new version after bump
+    const newVersion = await getVersion();
+    console.log(`New version: ${newVersion}`);
+    setOutput('new_version', newVersion);
+
+    // Check if there are changes to commit
+    const statusResult = await $`git status --porcelain`.run({ capture: true });
+    const status = statusResult.stdout.trim();
+
+    if (status) {
+      console.log('Changes detected, committing...');
+
+      // Stage all changes (package.json, package-lock.json, CHANGELOG.md, deleted changesets)
+      await $`git add -A`;
+
+      // Commit with version number as message
+      const commitMessage = newVersion;
+      const escapedMessage = commitMessage.replace(/"/g, '\\"');
+      await $`git commit -m "${escapedMessage}"`;
+
+      // Push directly to main
+      await $`git push origin main`;
+
+      console.log('\u2705 Version bump committed and pushed to main');
+      setOutput('version_committed', 'true');
+    } else {
+      console.log('No changes to commit');
+      setOutput('version_committed', 'false');
+    }
+  } catch (error) {
+    console.error('Error:', error.message);
+    process.exit(1);
+  }
+}
+
+main();