@quiltdata/benchling-webhook 0.4.13

package/bin/publish-manual.js

@@ -0,0 +1,211 @@
+#!/usr/bin/env node
+
+/**
+ * Manual NPM publish script using access token
+ *
+ * This script allows manual publishing to npmjs.org using an NPM access token.
+ * It's useful for:
+ * - Local testing of the publish process
+ * - Manual releases when CI/CD is unavailable
+ * - Emergency hotfix releases
+ *
+ * Prerequisites:
+ * 1. You must have an NPM access token with publish permissions
+ * 2. Set the token as environment variable: NPM_TOKEN=your_token_here
+ *
+ * Usage:
+ *   NPM_TOKEN=your_token npm run publish:manual
+ *   NPM_TOKEN=your_token npm run publish:manual -- --dry-run
+ *   NPM_TOKEN=your_token npm run publish:manual -- --tag beta
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const NPMRC_PATH = path.join(__dirname, '..', '.npmrc');
+const NPMRC_BACKUP_PATH = path.join(__dirname, '..', '.npmrc.backup');
+
+function validateToken() {
+  const token = process.env.NPM_TOKEN;
+
+  if (!token) {
+    console.error('❌ Error: NPM_TOKEN environment variable is not set');
+    console.error('');
+    console.error('Usage:');
+    console.error('  NPM_TOKEN=your_token_here npm run publish:manual');
+    console.error('');
+    console.error('To get an NPM access token:');
+    console.error('  1. Go to https://www.npmjs.com/settings/[your-username]/tokens');
+    console.error('  2. Click "Generate New Token"');
+    console.error('  3. Select "Automation" type for CI/CD or "Publish" for manual use');
+    console.error('  4. Copy the token and use it with this script');
+    process.exit(1);
+  }
+
+  return token;
+}
+
+function validateGitState() {
+  // Check for uncommitted changes
+  try {
+    execSync('git diff-index --quiet HEAD --', { stdio: 'ignore' });
+  } catch (e) {
+    console.error('⚠️  Warning: You have uncommitted changes');
+    console.error('   It is recommended to commit changes before publishing');
+    console.error('');
+
+    const readline = require('readline').createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+
+    return new Promise((resolve) => {
+      readline.question('Continue anyway? (y/N): ', (answer) => {
+        readline.close();
+        if (answer.toLowerCase() !== 'y') {
+          console.log('Aborted');
+          process.exit(1);
+        }
+        resolve();
+      });
+    });
+  }
+}
+
+function createNpmrc(token) {
+  // Backup existing .npmrc if it exists
+  if (fs.existsSync(NPMRC_PATH)) {
+    console.log('📋 Backing up existing .npmrc');
+    fs.copyFileSync(NPMRC_PATH, NPMRC_BACKUP_PATH);
+  }
+
+  // Create .npmrc with token
+  const npmrcContent = `//registry.npmjs.org/:_authToken=${token}\nregistry=https://registry.npmjs.org/\n`;
+  fs.writeFileSync(NPMRC_PATH, npmrcContent, { mode: 0o600 });
+  console.log('✅ Created .npmrc with authentication token');
+}
+
+function restoreNpmrc() {
+  // Remove the temporary .npmrc
+  if (fs.existsSync(NPMRC_PATH)) {
+    fs.unlinkSync(NPMRC_PATH);
+  }
+
+  // Restore backup if it exists
+  if (fs.existsSync(NPMRC_BACKUP_PATH)) {
+    console.log('📋 Restoring original .npmrc');
+    fs.renameSync(NPMRC_BACKUP_PATH, NPMRC_PATH);
+  }
+}
+
+function publishPackage(isDryRun, tag) {
+  const packagePath = path.join(__dirname, '..', 'package.json');
+  const pkg = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+
+  console.log('');
+  console.log('📦 Publishing package: ' + pkg.name);
+  console.log('📌 Version: ' + pkg.version);
+  if (tag) {
+    console.log('🏷️  Tag: ' + tag);
+  }
+  console.log('');
+
+  let publishCmd = 'npm publish --access public';
+
+  if (isDryRun) {
+    publishCmd += ' --dry-run';
+    console.log('🔍 Running in dry-run mode (no actual publish)');
+    console.log('');
+  }
+
+  if (tag) {
+    publishCmd += ` --tag ${tag}`;
+  }
+
+  try {
+    execSync(publishCmd, { stdio: 'inherit', cwd: path.join(__dirname, '..') });
+
+    if (isDryRun) {
+      console.log('');
+      console.log('✅ Dry run completed successfully');
+      console.log('   Remove --dry-run to publish for real');
+    } else {
+      console.log('');
+      console.log('✅ Package published successfully!');
+      console.log(`   View at: https://www.npmjs.com/package/${pkg.name}/v/${pkg.version}`);
+    }
+  } catch (error) {
+    console.error('');
+    console.error('❌ Failed to publish package');
+    throw error;
+  }
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+
+  if (args.includes('--help') || args.includes('-h')) {
+    const packagePath = path.join(__dirname, '..', 'package.json');
+    const pkg = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+
+    console.log('📦 Manual NPM Publish');
+    console.log('');
+    console.log('Current package:', pkg.name);
+    console.log('Current version:', pkg.version);
+    console.log('');
+    console.log('Usage:');
+    console.log('  NPM_TOKEN=token npm run publish:manual [options]');
+    console.log('');
+    console.log('Options:');
+    console.log('  --dry-run    Test the publish process without actually publishing');
+    console.log('  --tag TAG    Publish with a specific dist-tag (e.g., beta, next, latest)');
+    console.log('  --help, -h   Show this help message');
+    console.log('');
+    console.log('Examples:');
+    console.log('  NPM_TOKEN=npm_xxx npm run publish:manual');
+    console.log('  NPM_TOKEN=npm_xxx npm run publish:manual -- --dry-run');
+    console.log('  NPM_TOKEN=npm_xxx npm run publish:manual -- --tag beta');
+    console.log('');
+    console.log('Getting an NPM token:');
+    console.log('  1. Visit: https://www.npmjs.com/settings/[your-username]/tokens');
+    console.log('  2. Click "Generate New Token"');
+    console.log('  3. Choose "Automation" (for CI/CD) or "Publish" (for manual use)');
+    console.log('  4. Copy the token (it starts with "npm_")');
+    process.exit(0);
+  }
+
+  const isDryRun = args.includes('--dry-run');
+  const tagIndex = args.indexOf('--tag');
+  const tag = tagIndex !== -1 && args[tagIndex + 1] ? args[tagIndex + 1] : null;
+
+  console.log('🚀 Manual NPM Publish Script');
+  console.log('═'.repeat(50));
+
+  // Validate token
+  const token = validateToken();
+
+  // Validate git state
+  await validateGitState();
+
+  try {
+    // Create .npmrc with token
+    createNpmrc(token);
+
+    // Publish package
+    publishPackage(isDryRun, tag);
+  } catch (error) {
+    console.error('');
+    console.error('Publishing failed');
+    process.exit(1);
+  } finally {
+    // Always restore the original .npmrc
+    restoreNpmrc();
+  }
+}
+
+main().catch((error) => {
+  console.error('Unexpected error:', error);
+  restoreNpmrc();
+  process.exit(1);
+});

package/bin/release-notes.sh

@@ -0,0 +1,82 @@
+#!/bin/bash
+# Generate release notes for GitHub releases
+# Usage: ./bin/release-notes.sh VERSION IMAGE_URI [IS_PRERELEASE]
+
+set -e
+
+VERSION="${1}"
+IMAGE_URI="${2}"
+IS_PRERELEASE="${3:-false}"
+
+if [ -z "$VERSION" ] || [ -z "$IMAGE_URI" ]; then
+  echo "Usage: $0 VERSION IMAGE_URI [IS_PRERELEASE]"
+  echo "Example: $0 0.4.12 123456.dkr.ecr.us-west-2.amazonaws.com/quiltdata/benchling:0.4.12 false"
+  exit 1
+fi
+
+# Extract changelog notes if available
+CHANGELOG_NOTES=""
+if [ -f CHANGELOG.md ]; then
+  CHANGELOG_NOTES=$(sed -n "/## \[$VERSION\]/,/## \[/p" CHANGELOG.md | sed '$d' | sed '1d')
+fi
+
+# Generate release notes
+cat << EOFNOTES
+## Quick Start
+
+# 1. Configure
+cp env.template .env
+# Edit .env with AWS account, Benchling credentials, S3/SQS settings
+
+# 2. Install app-manifest.yaml as a Benchling app
+
+# 3. Deploy
+
+```
+set -a; source .env; set +a
+npx cdk bootstrap aws://\$CDK_DEFAULT_ACCOUNT/\$CDK_DEFAULT_REGION
+npm run check
+```
+
+# 4. Set Benchling webhook URL in the app overview page
+
+# 5. Insert a canvas into a notebook entry and click "Create"
+
+# 6. Set `experiment_id` in a package's metadata to link it to a notebook'
+
+
+\`\`\`
+
+## Docker Image
+
+For custom deployments, use the following Docker image:
+
+\`\`\`
+${IMAGE_URI}
+\`\`\`
+
+Pull and run:
+\`\`\`bash
+docker pull ${IMAGE_URI}
+\`\`\`
+
+EOFNOTES
+
+# Add changelog notes if available
+if [ -n "$CHANGELOG_NOTES" ]; then
+  echo ""
+  echo "## Changes"
+  echo ""
+  echo "$CHANGELOG_NOTES"
+fi
+
+# Add resources
+cat << EOFRESOURCES
+
+## Resources
+
+- [Installation Guide](https://github.com/quiltdata/benchling-webhook#installation)
+- [Configuration Guide](https://github.com/quiltdata/benchling-webhook#configuration)
+- [Development Guide](https://github.com/quiltdata/benchling-webhook/tree/main/docker)
+- [Release Process](https://github.com/quiltdata/benchling-webhook/blob/main/doc/RELEASE.md)
+EOFRESOURCES

package/bin/release.js

@@ -0,0 +1,118 @@
+#!/usr/bin/env node
+
+/**
+ * Release management script - creates and pushes git tags
+ *
+ * Usage:
+ *   node bin/release.js         # Create production release from current version
+ *   node bin/release.js dev     # Create dev release with timestamp from current version
+ *   node bin/release.js --no-push  # Create tag but don't push
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const packagePath = path.join(__dirname, '..', 'package.json');
+const pkg = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+
+function createGitTag(version, isDev, noPush) {
+  let tagName = `v${version}`;
+
+  // For dev releases, append timestamp to make unique
+  if (isDev) {
+    const timestamp = new Date().toISOString().replace(/[-:]/g, '').replace(/\.\d+Z$/, 'Z');
+    tagName = `v${version}-${timestamp}`;
+  }
+
+  const tagType = isDev ? 'pre-release (dev)' : 'release';
+
+  // Check if tag already exists
+  try {
+    execSync(`git rev-parse ${tagName}`, { stdio: 'ignore' });
+    console.error(`❌ Tag ${tagName} already exists`);
+    process.exit(1);
+  } catch (e) {
+    // Tag doesn't exist, continue
+  }
+
+  // Create tag
+  const message = isDev
+    ? `Development ${tagType} ${tagName}\n\nThis is a pre-release for testing purposes.`
+    : `Release ${tagName}`;
+
+  execSync(`git tag -a ${tagName} -m "${message}"`, { stdio: 'inherit' });
+  console.log(`✅ Created git tag ${tagName}`);
+
+  // Push tag unless --no-push is specified
+  if (!noPush) {
+    console.log('');
+    console.log(`Pushing tag ${tagName} to origin...`);
+    try {
+      execSync(`git push origin ${tagName}`, { stdio: 'inherit' });
+      console.log(`✅ Pushed tag ${tagName} to origin`);
+      console.log('');
+      console.log('CI/CD pipeline will now:');
+      console.log('  - Run all tests');
+      console.log('  - Build and push Docker image to ECR');
+      console.log('  - Create GitHub release');
+      if (!isDev) {
+        console.log('  - Publish to NPM (production releases only)');
+      }
+      console.log('  - Publish to GitHub Packages');
+      console.log('');
+      console.log('Monitor progress at: https://github.com/quiltdata/benchling-webhook/actions');
+    } catch (error) {
+      console.error(`❌ Failed to push tag ${tagName}`);
+      console.error('You can manually push with: git push origin ' + tagName);
+      process.exit(1);
+    }
+  } else {
+    console.log('');
+    console.log('Tag created but not pushed (--no-push specified)');
+    console.log(`To push later: git push origin ${tagName}`);
+  }
+}
+
+function main() {
+  const args = process.argv.slice(2);
+
+  // Check for uncommitted changes
+  try {
+    execSync('git diff-index --quiet HEAD --', { stdio: 'ignore' });
+  } catch (e) {
+    console.error('❌ You have uncommitted changes');
+    console.error('   Commit or stash your changes before creating a release');
+    process.exit(1);
+  }
+
+  const isDev = args.includes('dev');
+  const noPush = args.includes('--no-push');
+  const version = pkg.version;
+
+  if (args.includes('--help') || args.includes('-h')) {
+    console.log('Current version:', version);
+    console.log('');
+    console.log('Usage: node bin/release.js [dev] [--no-push]');
+    console.log('');
+    console.log('Commands:');
+    console.log('  (no args)  - Create production release tag and push');
+    console.log('  dev        - Create dev release tag with timestamp and push');
+    console.log('');
+    console.log('Options:');
+    console.log('  --no-push  - Create tag but do not push to origin');
+    console.log('');
+    console.log('Examples:');
+    console.log('  node bin/release.js              # Create v0.4.12 and push');
+    console.log('  node bin/release.js dev          # Create v0.4.12-20251027T123456Z and push');
+    console.log('  node bin/release.js --no-push    # Create tag but don\'t push');
+    process.exit(0);
+  }
+
+  console.log(`Creating ${isDev ? 'dev' : 'production'} release from version: ${version}`);
+  console.log('');
+
+  createGitTag(version, isDev, noPush);
+}
+
+main();

package/bin/send-event.js

@@ -0,0 +1,203 @@
+#!/usr/bin/env node
+/**
+ * Send a test event to the deployed Benchling webhook endpoint
+ */
+
+require("dotenv/config");
+const { execSync } = require("child_process");
+const fs = require("fs");
+const path = require("path");
+
+const STACK_NAME = "BenchlingWebhookStack";
+
+// Validate required environment variables
+if (!process.env.CDK_DEFAULT_REGION) {
+    console.error("Error: CDK_DEFAULT_REGION is not set in .env file");
+    console.error("Please set CDK_DEFAULT_REGION in your .env file");
+    process.exit(1);
+}
+
+const AWS_REGION = process.env.CDK_DEFAULT_REGION;
+
+function getStackOutputs() {
+    try {
+        const output = execSync(
+            `aws cloudformation describe-stacks --stack-name ${STACK_NAME} --region ${AWS_REGION} --query 'Stacks[0].Outputs' --output json`,
+            { encoding: "utf-8" },
+        );
+        return JSON.parse(output);
+    } catch (error) {
+        console.error(`Error: Could not get stack outputs for ${STACK_NAME}`);
+        console.error("Make sure the stack is deployed and AWS credentials are configured.");
+        process.exit(1);
+    }
+}
+
+function getWebhookEndpoint(outputs) {
+    const endpoint = outputs.find((o) => o.OutputKey === "WebhookEndpoint");
+    if (!endpoint) {
+        console.error("Error: Could not find WebhookEndpoint in stack outputs");
+        process.exit(1);
+    }
+    return endpoint.OutputValue;
+}
+
+function listTestEvents() {
+    const eventsDir = path.join(__dirname, "..", "test-events");
+    const files = fs.readdirSync(eventsDir).filter(f => f.endsWith(".json"));
+
+    console.log("Available test events:");
+    files.forEach(file => {
+        console.log(`  - ${file.replace(".json", "")}`);
+    });
+}
+
+function loadTestEvent(eventName) {
+    const eventsDir = path.join(__dirname, "..", "test-events");
+
+    // Add .json extension if not present
+    if (!eventName.endsWith(".json")) {
+        eventName = `${eventName}.json`;
+    }
+
+    const eventPath = path.join(eventsDir, eventName);
+
+    if (!fs.existsSync(eventPath)) {
+        console.error(`Error: Test event file not found: ${eventPath}`);
+        console.error("");
+        listTestEvents();
+        process.exit(1);
+    }
+
+    return fs.readFileSync(eventPath, "utf-8");
+}
+
+function sendEvent(endpoint, eventData, eventName, dryRun = false) {
+    // Determine the endpoint path based on event type
+    const event = JSON.parse(eventData);
+    let path = "/";
+
+    if (event.message?.type) {
+        const type = event.message.type;
+        if (type.includes("canvas")) {
+            path = "/canvas";
+        } else if (type.includes("entry")) {
+            path = "/entry";
+        } else if (type.includes("app")) {
+            path = "/app";
+        }
+    }
+
+    const url = endpoint.replace(/\/$/, "") + path;
+
+    console.log("=".repeat(80));
+    console.log("Sending Test Event");
+    console.log("=".repeat(80));
+    console.log(`Event:    ${eventName}`);
+    console.log(`Type:     ${event.message?.type || "unknown"}`);
+    console.log(`Endpoint: ${url}`);
+    console.log("=".repeat(80));
+    console.log("");
+
+    if (dryRun) {
+        console.log("DRY RUN - Would send the following payload:");
+        console.log(JSON.stringify(JSON.parse(eventData), null, 2));
+        return;
+    }
+
+    // Create a temporary file for the event data
+    const tmpFile = `/tmp/benchling-event-${Date.now()}.json`;
+    fs.writeFileSync(tmpFile, eventData);
+
+    try {
+        console.log("Sending request...");
+        const command = `curl -X POST "${url}" \\
+            -H "Content-Type: application/json" \\
+            -H "webhook-id: msg_test_${Date.now()}" \\
+            -H "webhook-timestamp: ${Math.floor(Date.now() / 1000)}" \\
+            -H "webhook-signature: v1,test_signature" \\
+            --data @${tmpFile} \\
+            -w "\\n\\nHTTP Status: %{http_code}\\n" \\
+            -v`;
+
+        console.log("");
+        execSync(command, { stdio: "inherit", shell: "/bin/bash" });
+        console.log("");
+        console.log("=".repeat(80));
+        console.log("Event sent successfully!");
+        console.log("Check logs with: npm run logs");
+        console.log("=".repeat(80));
+    } catch (error) {
+        console.error("\nError sending event:", error.message);
+        process.exit(1);
+    } finally {
+        // Clean up temp file
+        if (fs.existsSync(tmpFile)) {
+            fs.unlinkSync(tmpFile);
+        }
+    }
+}
+
+function printHelp() {
+    console.log("Usage: npm run event [event-name] [options]");
+    console.log("");
+    console.log("Arguments:");
+    console.log("  event-name         Name of test event file (without .json extension)");
+    console.log("                     Defaults to 'canvas-created' if not specified");
+    console.log("");
+    console.log("Options:");
+    console.log("  --list, -l         List available test events");
+    console.log("  --dry-run, -d      Show what would be sent without actually sending");
+    console.log("  --help, -h         Show this help message");
+    console.log("");
+    console.log("Examples:");
+    console.log("  npm run event                          # Send canvas-created.json (default)");
+    console.log("  npm run event canvas-created           # Send canvas-created.json event");
+    console.log("  npm run event entry-updated            # Send entry-updated.json event");
+    console.log("  npm run event -- --list                # List all available events");
+    console.log("  npm run event canvas-created -- --dry-run   # Preview without sending");
+    console.log("");
+    console.log("After sending an event, check the logs:");
+    console.log("  npm run logs");
+}
+
+function main() {
+    const args = process.argv.slice(2);
+
+    if (args.includes("--help") || args.includes("-h")) {
+        printHelp();
+        process.exit(0);
+    }
+
+    if (args.includes("--list") || args.includes("-l")) {
+        listTestEvents();
+        process.exit(0);
+    }
+
+    const dryRun = args.includes("--dry-run") || args.includes("-d");
+    const eventName = args.find(arg => !arg.startsWith("-")) || "canvas-created";
+
+    // If using default event, notify the user
+    if (!args.find(arg => !arg.startsWith("-"))) {
+        console.log("No event specified, using default: canvas-created\n");
+    }
+
+    // Get webhook endpoint from stack outputs
+    const outputs = getStackOutputs();
+    const endpoint = getWebhookEndpoint(outputs);
+
+    // Load test event
+    const eventData = loadTestEvent(eventName);
+
+    // Send event
+    sendEvent(endpoint, eventData, eventName, dryRun);
+}
+
+if (require.main === module) {
+    try {
+        main();
+    } catch (error) {
+        console.error("Error:", error.message);
+        process.exit(1);
+    }
+}

package/bin/sync-version.js

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+/**
+ * Synchronize version between package.json, docker/pyproject.toml, and docker/app-manifest.yaml
+ * The source of truth is docker/pyproject.toml
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const PYPROJECT_PATH = path.join(__dirname, '..', 'docker', 'pyproject.toml');
+const PACKAGE_JSON_PATH = path.join(__dirname, '..', 'package.json');
+const APP_MANIFEST_PATH = path.join(__dirname, '..', 'docker', 'app-manifest.yaml');
+
+function extractVersionFromPyproject(content) {
+  const match = content.match(/^version\s*=\s*"([^"]+)"/m);
+  if (!match) {
+    throw new Error('Could not find version in pyproject.toml');
+  }
+  return match[1];
+}
+
+function updateAppManifest(version) {
+  const content = fs.readFileSync(APP_MANIFEST_PATH, 'utf-8');
+  const updatedContent = content.replace(
+    /^version:\s*.+$/m,
+    `version: ${version}`
+  );
+  
+  if (content !== updatedContent) {
+    fs.writeFileSync(APP_MANIFEST_PATH, updatedContent);
+    return true;
+  }
+  return false;
+}
+
+function main() {
+  // Read pyproject.toml
+  const pyprojectContent = fs.readFileSync(PYPROJECT_PATH, 'utf-8');
+  const version = extractVersionFromPyproject(pyprojectContent);
+
+  console.log(`Version from docker/pyproject.toml: ${version}`);
+
+  // Update package.json
+  const packageJson = JSON.parse(fs.readFileSync(PACKAGE_JSON_PATH, 'utf-8'));
+  const oldVersion = packageJson.version;
+
+  if (oldVersion !== version) {
+    packageJson.version = version;
+    fs.writeFileSync(PACKAGE_JSON_PATH, JSON.stringify(packageJson, null, 2) + '\n');
+    console.log(`✓ Updated package.json version: ${oldVersion} → ${version}`);
+  } else {
+    console.log(`✓ package.json version already matches: ${version}`);
+  }
+
+  // Update app-manifest.yaml
+  if (updateAppManifest(version)) {
+    console.log(`✓ Updated app-manifest.yaml version to: ${version}`);
+  } else {
+    console.log(`✓ app-manifest.yaml version already matches: ${version}`);
+  }
+}
+
+if (require.main === module) {
+  try {
+    main();
+  } catch (error) {
+    console.error('Error:', error.message);
+    process.exit(1);
+  }
+}
+
+module.exports = { extractVersionFromPyproject };