cloudmason2 1.0.0

package/commands/update_app.js

@@ -0,0 +1,279 @@
+const path = require('path');
+const fs = require('fs');
+const AdmZip = require("adm-zip");
+const { S3Client, PutObjectCommand, GetObjectCommand } = require("@aws-sdk/client-s3");
+const { EC2Client, DescribeRegionsCommand, DescribeImagesCommand, DeregisterImageCommand, DeleteSnapshotCommand } = require("@aws-sdk/client-ec2");
+const OrgConfig = require('./helpers/org_config');
+const Apps = require('./helpers/apps');
+const { buildAMI } = require('./ssh_build');
+
+exports.main = async function(args){
+    console.log(`Updating ${args.app} v${args.v}`);
+
+    // Check Version Format
+    if (!args.v.match(/^[1-9][0-9]{0,4}\.[0-9]{0,4}$/)){
+        console.log('Invalid Version Format. Use format [major].[minor] without leading 0s');
+        throw new Error('Invalid Version Format');
+    }
+
+    const cfg = OrgConfig.read();
+    if (!cfg){ throw new Error('No org config found. Run set-org') }
+    const { bucket, prefix } = parseCdn(cfg.cdn);
+    const s3 = new S3Client({ region: cfg.region });
+    process.env.orgRegion = cfg.region; // used by ssh_build
+
+    const appName = args.app.toLowerCase();
+
+    // Get App
+    const app = await Apps.resolveApp(s3, bucket, prefix, appName);
+    if (!app){ throw new Error('No app named ' + args.app + '. Run new-app') }
+    const { appPrefix, manifest } = app;
+
+    // Published versions are frozen: no further updates to the same major/minor
+    const existing = manifest.versions.find(v=>{ return v.version === args.v || v.version.startsWith(args.v + '.') });
+    if (existing && existing.published){
+        throw new Error(`v${existing.version} is published. Use a new major/minor version`);
+    }
+
+    // --- I PREP ZIP ---
+    const zipPath = path.resolve(args.path);
+    if (!fs.existsSync(zipPath)){ throw new Error("Path not found:" + zipPath) }
+    const zipFilePath = await prepZip(zipPath);
+
+    // Stored as _app.zip so the CDN public-access policy keeps it private
+    const versionPrefix = `${appPrefix}/versions/${args.v}`;
+    await uploadFile(s3, bucket, `${versionPrefix}/_app.zip`, zipFilePath);
+    console.log(`Uploaded s3://${bucket}/${versionPrefix}/_app.zip`);
+
+    // --- II GET STACK ---
+    const stackKey = `${versionPrefix}/stack.yaml`;
+    let stackText;
+    if (args.stack){
+        const stackPath = path.resolve(args.stack);
+        if (!fs.existsSync(stackPath)){ throw new Error("Stack not found:" + stackPath) }
+        stackText = fs.readFileSync(stackPath, 'utf-8');
+    } else {
+        stackText = await getFileText(s3, bucket, stackKey);
+        if (stackText === null){ throw new Error('No stack found for v' + args.v + '. Pass -stack') }
+    }
+
+    // --- III BUILD IMAGE ---
+    const buildTime = new Date();
+    const ts = buildTime.toISOString().slice(0, 16).replace(/[-:]/g, ''); // e.g. 20260826T2130
+    const fullVersion = `${args.v}.${ts}`;
+
+    let ami_id = null;
+    if (manifest.noami){
+        console.log('noami app: skipping AMI build');
+    } else {
+        const amiName = `${appName}-v${fullVersion}`;
+        const arch = archFromInstanceType(manifest.RecommendedInstanceType || 'r8g.medium');
+        const buildInstanceType = arch === 'arm' ? 'r8g.medium' : 'm6a.large';
+
+        console.log(`Building AMI: ${amiName} (${arch}, ${buildInstanceType})`);
+        console.log(`Using local zip: ${zipFilePath}`);
+
+        try {
+            ami_id = await buildAMI(amiName, zipFilePath, buildInstanceType, arch);
+        } catch(e) {
+            console.log("Error Creating AMI:" + e);
+            throw new Error("Error - Build Not Complete");
+        }
+    }
+
+    // --- IV UPLOAD STACK ---
+    // Only alteration to the template: set the AmiId parameter's Default to the new AMI
+    let finalStack = stackText;
+    if (ami_id){
+        const amiDefault = setAmiDefault(stackText, ami_id);
+        finalStack = amiDefault.text;
+        if (amiDefault.updated){
+            console.log(`Set AmiId parameter Default to ${ami_id}`);
+        } else {
+            console.log('No AmiId parameter found in stack. Template unchanged');
+        }
+    }
+    await s3.send(new PutObjectCommand({ Bucket: bucket, Key: stackKey, Body: finalStack }));
+    console.log(`Uploaded s3://${bucket}/${stackKey}`);
+
+    // --- V UPDATE MANIFEST ---
+    // One entry per major.minor: drop any prior patch versions of this version
+    manifest.versions = manifest.versions.filter(v=>{ return !v.version.startsWith(args.v + '.') && v.version !== args.v });
+    manifest.versions.push({
+        version: fullVersion,
+        updated_on: buildTime.toISOString(),
+        ami_id: ami_id,
+        stack_url: `https://${bucket}.s3.${cfg.region}.amazonaws.com/${stackKey}`
+    });
+    await putManifest(s3, bucket, appPrefix, manifest);
+    console.log(`Recorded v${fullVersion} (${ami_id}) in manifest`);
+
+    // --- VI PRUNE AMIS ---
+    // Fire and forget: keep only the newest build per major.minor across all regions
+    if (!manifest.noami){
+        prune_amis(appName, cfg.region).catch(e=>{ console.log('Prune failed: ' + e.message) });
+    }
+
+    return true;
+}
+
+
+///////////////////////////////////////////////
+///////////////////////////////////////////////
+///////////////////////////////////////////////
+
+function parseCdn(cdn){
+    const p = cdn.trim().replace(/^s3:\/\//i, '').replace(/\/+$/, '');
+    const parts = p.split('/');
+    return { bucket: parts[0], prefix: parts.slice(1).join('/') };
+}
+
+// Graviton instance families end in g (r8g, m7g, t4g) and need arm64 AMIs
+function archFromInstanceType(instanceType){
+    const family = instanceType.split('.')[0];
+    return /[0-9]g/.test(family) ? 'arm' : 'x86_64';
+}
+
+async function prepZip(appPath){
+    console.log('Zipping ' + appPath);
+    const inPath = path.resolve(appPath);
+    let zipPath = path.resolve(`./app.zip`);
+
+    const pathStat = fs.statSync(inPath);
+    // If dir, zip
+    if (!pathStat.isFile()){
+        const zip = new AdmZip();
+        zip.addLocalFolder(inPath);
+        zip.writeZip(zipPath);
+    } else {
+        // If not zip, throw error
+        if (path.extname(inPath) !== '.zip'){
+            console.log('ERROR:Not a .zip file >>' + inPath)
+            throw 'ERROR:Not a .zip file >>' + inPath;
+        }
+        // Copy .zip file
+        fs.copyFileSync(inPath,zipPath);
+    }
+    process.on('exit', function(){ fs.unlinkSync(zipPath) });
+    return zipPath;
+}
+
+async function uploadFile(s3, bucket, key, localPath){
+    await s3.send(new PutObjectCommand({
+        Bucket: bucket,
+        Key: key,
+        Body: fs.createReadStream(localPath)
+    }));
+}
+
+// Remove earlier builds of this app in every region, keeping only the newest AMI per major.minor
+async function prune_amis(appName, orgRegion){
+    const ec2 = new EC2Client({ region: orgRegion });
+    const r = await ec2.send(new DescribeRegionsCommand({}));
+    const regions = r.Regions.map(rg=>{ return rg.RegionName });
+
+    for (const region of regions){
+        try {
+            await pruneRegion(appName, region);
+        } catch (e){
+            console.log(`Prune failed in ${region}: ${e.message}`);
+        }
+    }
+}
+
+async function pruneRegion(appName, region){
+    const client = new EC2Client({ region });
+    const r = await client.send(new DescribeImagesCommand({
+        Owners: ['self'],
+        Filters: [{ Name: 'name', Values: [`${appName}-v*`] }]
+    }));
+    if (!r.Images || r.Images.length === 0){ return }
+
+    // Group builds by major.minor. Name format: app-v[major.minor].[timestamp]
+    const groups = {};
+    r.Images.forEach(img=>{
+        const m = img.Name.match(/-v([0-9]+\.[0-9]+)\.(.+)$/);
+        if (!m){ return }
+        (groups[m[1]] = groups[m[1]] || []).push(img);
+    });
+
+    for (const v of Object.keys(groups)){
+        // Timestamps are fixed-width (YYYYMMDDTHHMM) so names sort chronologically
+        const builds = groups[v].sort((a,b)=>{ return a.Name < b.Name ? 1 : -1 });
+        for (const img of builds.slice(1)){
+            console.log(`Pruning ${img.Name} (${img.ImageId}) in ${region}`);
+            await client.send(new DeregisterImageCommand({ ImageId: img.ImageId }));
+            for (const bdm of (img.BlockDeviceMappings || [])){
+                if (bdm.Ebs && bdm.Ebs.SnapshotId){
+                    await client.send(new DeleteSnapshotCommand({ SnapshotId: bdm.Ebs.SnapshotId }));
+                }
+            }
+        }
+    }
+}
+
+async function getFileText(s3, bucket, key){
+    try {
+        const r = await s3.send(new GetObjectCommand({ Bucket: bucket, Key: key }));
+        return await r.Body.transformToString();
+    } catch (e){
+        if (/NoSuchKey|NotFound/.test(e)){ return null }
+        throw e;
+    }
+}
+
+// Set Default on the AmiId parameter, touching nothing else in the template.
+// JSON templates are parsed; YAML templates get a single-line text edit.
+function setAmiDefault(stackText, amiId){
+    if (stackText.trim().startsWith('{')){
+        const tpl = JSON.parse(stackText);
+        if (!tpl.Parameters || !tpl.Parameters.AmiId){ return { text: stackText, updated: false } }
+        tpl.Parameters.AmiId.Default = amiId;
+        return { text: JSON.stringify(tpl, null, 4), updated: true };
+    }
+
+    const lines = stackText.split(/\r?\n/);
+    // Find top-level Parameters section
+    const pStart = lines.findIndex(l=>{ return /^Parameters:\s*(#.*)?$/.test(l) });
+    if (pStart === -1){ return { text: stackText, updated: false } }
+
+    // Find the AmiId key inside Parameters (stop at the next top-level section)
+    let amiLine = -1;
+    let amiIndent = 0;
+    for (let i=pStart+1; i<lines.length; i++){
+        if (/^\S/.test(lines[i])){ break }
+        const m = lines[i].match(/^(\s+)AmiId:\s*(#.*)?$/);
+        if (m){ amiLine = i; amiIndent = m[1].length; break }
+    }
+    if (amiLine === -1){ return { text: stackText, updated: false } }
+
+    // Scan the AmiId block for an existing Default line
+    let blockEnd = lines.length;
+    for (let i=amiLine+1; i<lines.length; i++){
+        if (lines[i].trim() === ''){ continue }
+        const indent = lines[i].match(/^\s*/)[0].length;
+        if (indent <= amiIndent){ blockEnd = i; break }
+        const dm = lines[i].match(/^(\s+)Default:\s*/);
+        if (dm){
+            lines[i] = `${dm[1]}Default: ${amiId}`;
+            return { text: lines.join('\n'), updated: true };
+        }
+    }
+
+    // No Default line - insert one right after AmiId:, matching the block's indentation
+    let childIndent = ' '.repeat(amiIndent + 2);
+    for (let i=amiLine+1; i<blockEnd; i++){
+        if (lines[i].trim() !== ''){ childIndent = lines[i].match(/^\s*/)[0]; break }
+    }
+    lines.splice(amiLine+1, 0, `${childIndent}Default: ${amiId}`);
+    return { text: lines.join('\n'), updated: true };
+}
+
+async function putManifest(s3, bucket, appPrefix, manifest){
+    await s3.send(new PutObjectCommand({
+        Bucket: bucket,
+        Key: `${appPrefix}/manifest.json`,
+        Body: JSON.stringify(manifest, null, 4),
+        ContentType: 'application/json'
+    }));
+}

package/commands/update_listing.js

@@ -0,0 +1,124 @@
+const fs = require('fs');
+const path = require('path');
+const { S3Client, PutObjectCommand } = require("@aws-sdk/client-s3");
+const OrgConfig = require('./helpers/org_config');
+const Apps = require('./helpers/apps');
+
+// Marketplace listing text files stored as top-level manifest attributes.
+// Names match the keys the AWS Marketplace Catalog API expects
+const TEXT_ASSETS = ['ShortDescription', 'LongDescription', 'UsageInstructions', 'SupportDescription'];
+// Images uploaded to s3; their public URLs stored under the AWS attribute name
+const IMAGE_ASSETS = [
+    { file: 'ArchitectureDiagram.png', attr: 'ArchitectureDiagram' },
+    { file: 'Logo.png', attr: 'LogoUrl' }
+];
+
+// update-listing: update the manifest from the assets folder and/or set the product id
+exports.main = async function(args){
+    const cfg = OrgConfig.read();
+    if (!cfg){ throw new Error('No org config found. Run set-org') }
+    const { bucket, prefix } = parseCdn(cfg.cdn);
+    const s3 = new S3Client({ region: cfg.region });
+
+    const appName = args.app.toLowerCase();
+
+    const app = await Apps.resolveApp(s3, bucket, prefix, appName);
+    if (!app){ throw new Error('No app named ' + args.app + '. Run new-app') }
+    const { appPrefix, manifest } = app;
+
+    if (!args.assets && !args.pid && !args.ec2){
+        console.log('Nothing to update. Pass -assets, -pid, or -ec2');
+        return true;
+    }
+
+    // Apply all manifest updates in one download/update/upload pass
+    if (args.assets){
+        await applyAssets(s3, bucket, appPrefix, cfg.region, args.assets, manifest);
+    }
+    if (args.pid){
+        manifest.productId = args.pid;
+        console.log('Set productId');
+    }
+    if (args.ec2){
+        manifest.RecommendedInstanceType = args.ec2;
+        console.log('Set RecommendedInstanceType');
+    }
+    await putManifest(s3, bucket, appPrefix, manifest);
+    console.log('Updated manifest');
+    return true;
+}
+
+
+/////////////////////////////////////////
+////////////// FUNCS ////////////////////
+////////////////////////////////////////
+
+function parseCdn(cdn){
+    const p = cdn.trim().replace(/^s3:\/\//i, '').replace(/\/+$/, '');
+    const parts = p.split('/');
+    return { bucket: parts[0], prefix: parts.slice(1).join('/') };
+}
+
+// Listing text files go into the manifest; only images are uploaded as files.
+// Empty placeholder files are skipped so they never blank out existing values
+async function applyAssets(s3, bucket, appPrefix, region, assetsPath, manifest){
+    if (!fs.existsSync(assetsPath)){ throw new Error('Assets path does not exist: ' + assetsPath) }
+
+    TEXT_ASSETS.forEach(name=>{
+        const filePath = path.join(assetsPath, `${name}.txt`);
+        if (!fs.existsSync(filePath) || fs.readFileSync(filePath, 'utf-8').trim() === ''){
+            console.log(`Skipping ${name}: no content in ${name}.txt`);
+            return;
+        }
+        manifest[name] = fs.readFileSync(filePath, 'utf-8');
+        console.log(`Set ${name}`);
+    });
+
+    // VideoUrls.txt: one URL per line (AWS currently supports a single URL)
+    const videoPath = path.join(assetsPath, 'VideoUrls.txt');
+    if (fs.existsSync(videoPath)){
+        const urls = fs.readFileSync(videoPath, 'utf-8').split('\n').map(l=>{ return l.trim() }).filter(l=>{ return l });
+        if (urls.length){
+            manifest.VideoUrls = urls;
+            console.log('Set VideoUrls');
+        }
+    }
+
+    // AdditionalResources.json: array of { Text, Url }
+    const resPath = path.join(assetsPath, 'AdditionalResources.json');
+    if (fs.existsSync(resPath)){
+        const raw = fs.readFileSync(resPath, 'utf-8').trim();
+        if (raw && raw !== '[]'){
+            let resources;
+            try { resources = JSON.parse(raw) } catch (e){ throw new Error('AdditionalResources.json is not valid JSON') }
+            manifest.AdditionalResources = resources;
+            console.log('Set AdditionalResources');
+        }
+    }
+
+    for (const img of IMAGE_ASSETS){
+        const imgPath = path.join(assetsPath, img.file);
+        if (!fs.existsSync(imgPath) || fs.statSync(imgPath).size === 0){
+            console.log(`Skipping ${img.attr}: no content in ${img.file}`);
+            continue;
+        }
+        const key = `${appPrefix}/marketplace/${img.file}`;
+        await s3.send(new PutObjectCommand({
+            Bucket: bucket,
+            Key: key,
+            Body: fs.createReadStream(imgPath),
+            ContentType: 'image/png'
+        }));
+        manifest[img.attr] = `https://${bucket}.s3.${region}.amazonaws.com/${key}`;
+        console.log(`Uploaded ${img.file}: ${manifest[img.attr]}`);
+    }
+}
+
+async function putManifest(s3, bucket, appPrefix, manifest){
+    await s3.send(new PutObjectCommand({
+        Bucket: bucket,
+        Key: `${appPrefix}/manifest.json`,
+        Body: JSON.stringify(manifest, null, 4),
+        ContentType: 'application/json'
+    }));
+}

package/main.js

@@ -0,0 +1,202 @@
+#!/usr/bin/env node
+
+const Commands = {
+    'create-cdn': {
+        desc: "Create a CDN bucket with public access policy and marketplace role",
+        exec: require('./commands/create_cdn').main,
+        args: [
+            {n: 'name', desc: 'CDN bucket name (lowercase letters, numbers, hyphens)', pattern: `^[a-z0-9][a-z0-9-]{1,61}[a-z0-9]$`, r: true}
+        ]
+    },
+    'set-org': {
+        desc: "Set the organization CDN",
+        exec: require('./commands/init_org').main,
+        args: [
+            {n: 'cdn', desc: 'CDN bucket name from create-cdn (e.g. cdn-theorim-io)', pattern: `^[a-z0-9][a-z0-9-]{1,61}[a-z0-9]$`, r: true}
+        ]
+    },
+    'new-app': {
+        desc: 'Create a new application',
+        exec: require('./commands/new_app').main,
+        args: [
+            {n: 'name', desc: 'Application name (letters only)', pattern: `^[A-Za-z]{2,20}$`, r: true},
+            {n: 'repo', desc: 'GitHub repo (org/repo). Creates a CI role assumable by GitHub Actions from that repo', r: false},
+            {n: 'noami', desc: 'Serverless app: update-app skips the AMI build and launch passes no AmiId', r: false},
+            {n: 'private', desc: 'Store the app under a private _ folder (not publicly accessible)', r: false}
+        ]
+    },
+    'update-listing': {
+        desc: 'Update marketplace listing details',
+        exec: require('./commands/update_listing').main,
+        args: [
+            {n: 'app', desc: 'Name of existing app', pattern: `^[A-Za-z]{2,20}$`, r: true},
+            {n: 'assets', desc: 'Path to folder with application assets', r: false},
+            {n: 'pid', desc: 'AWS Product ID', r: false},
+            {n: 'ec2', desc: 'Instance type (default r8g.medium)', r: false}
+        ]
+    },
+    'update-app': {
+        desc: 'Update application',
+        exec: require('./commands/update_app').main,
+        args: [
+            {n: 'app', desc: 'Name of existing app', pattern: `^[A-Za-z]{2,20}$`, r: true},
+            {n: 'v', desc: 'Version to update', pattern: `[0-9]{1,20}`, r: true},
+            {n: 'path', desc: 'Path to app zip file or folder', r: true},
+            {n: 'stack', desc: 'Path to updated JSON or YML stack', r: false},
+        ]
+    },
+    'launch': {
+        desc: 'Launch application version to an instance',
+        exec: require('./commands/launch_app').main,
+        args: [
+            {n: 'app', desc: 'Name of existing app', pattern: `^[A-Za-z]{2,20}$`, r: true},
+            {n: 'v', desc: 'Version to launch', pattern: `[0-9]{1,20}`, r: true},
+            {n: 'title', desc: 'Title of the version', pattern: `^[A-Za-z][A-Za-z0-9-]{1,30}$`, r: true},
+            {n: 'region', desc: 'AWS Region to launch the instance', pattern: `^[a-z]{2}-[a-z]+-[0-9]$`, r: true},
+        ]
+    },
+    'publish': {
+        desc: 'Publish app to marketplace',
+        exec: require('./commands/publish').main,
+        args: [
+            {n: 'app', desc: 'Name of existing app', pattern: `^[A-Za-z]{2,20}$`, r: true},
+            {n: 'desc', desc: 'Description of Changes', r: true},
+            {n: 'v', desc: 'Version to launch', pattern: `[0-9]{1,20}`, r: true},
+            {n: 'await', desc: 'Wait for marketplace processing to complete (up to 90m)', r: false}
+        ]
+    },
+    /////
+    'delete-app': {
+        desc: 'Delete app',
+        exec: require('./commands/delete').delete_app,
+        args: [
+            {n: 'app', desc: 'Name of existing app', pattern: `^[A-Za-z]{2,20}$`, r: true}
+        ]
+    },
+    'delete-instance': {
+        desc: 'Delete instance (rolls back its stack)',
+        exec: require('./commands/delete').delete_instance,
+        args: [
+            {n: 'app', desc: 'Name of existing app', pattern: `^[A-Za-z]{2,20}$`, r: true},
+            {n: 'title', desc: 'Instance title used on launch', pattern: `^[A-Za-z][A-Za-z0-9-]{1,30}$`, r: true},
+            {n: 'region', desc: 'Region of the stack (searched across all regions if omitted)', pattern: `^[a-z]{2}-[a-z]+-[0-9]$`, r: false},
+        ]
+    },
+    'list-apps': {
+        desc: 'List all apps',
+        exec: require('./commands/list_apps').main
+    },
+    'app-details': {
+        desc: 'Get details of an existing app',
+        exec: require('./commands/app_details').main,
+        args: [
+            {n: 'app', desc: 'Name of existing app', pattern: `^[A-Za-z]{2,20}$`, r: true}
+        ]
+    }
+}
+
+async function main(){
+    const args = parseArgs();
+    // Print info if no command given
+    if (!args.cmd){
+        printAllInfo();
+        return;
+    }
+
+    // Check for valid command
+    if (!Commands[args.cmd]){
+        console.log('Invalid command. Run without args to list commands');
+        return;
+    }
+    // If Command has args, but none are give, print info
+    if (Commands[args.cmd].args && Object.keys(args.args).length == 0){
+        printCmdInfo(args.cmd);
+        return
+    }
+
+    // Validate args
+    const valid = validateArgs(args);
+    if (!valid){ 
+        console.log('FAILED:Invalid Arguments')
+        process.exit(1);
+    }
+    // Exec Command
+    try{
+        await Commands[args.cmd].exec(args.args);
+    } catch (e){
+        const errLocation = e.stack ? e.stack.split('\n')[1].replace(/.*\\/,'') : e.at;
+        console.log('FAILED>>' + e.message + ' @ ' + errLocation);
+        process.exit(1)
+    }
+    console.log('SUCCESS')
+}
+
+
+/////////////////////////////////
+////////////////////////////////
+
+
+
+function parseArgs(){
+    var args = {
+        cmd: process.argv[2],
+        args: {}
+    };
+    for (let i=0;i<process.argv.length; i++){
+        if (process.argv[i][0] === '-'){
+            args.args[process.argv[i].replace('-','')] = null;
+            if (process.argv[i+1] && process.argv[i+1][0] !== '-'){
+                args.args[process.argv[i].replace('-','')] = process.argv[i+1];
+                i += 1
+            }
+        }
+    }
+    return args;
+}
+
+function printAllInfo(){
+    Object.entries(Commands).forEach((c)=>{   
+        console.log(`| ${c[0]} ${c[1].desc}`)
+        if (c[1].args){
+            c[1].args.forEach(a=>{
+                const argName = a.r ? `${a.n}*` : a.n;
+                console.log(`\t-${argName}: ${a.desc}`)
+            })
+        }
+        console.log('-------\n');
+    })
+    console.log('\n*required')
+}
+
+function printCmdInfo(cmd){
+    const comm = Commands[cmd].args;
+    console.log('\n' + cmd)
+    comm.forEach(a=>{
+        const argName = a.r ? `${a.n}*` : a.n;
+        console.log(`\t-${argName}: ${a.desc}`)
+    })
+    console.log('-------\n');
+}
+
+function validateArgs(args){
+    const command = Commands[args.cmd];
+    if (!command.args){ return true }
+    for (let i=0; i<command.args.length;i++){
+        let carg = command.args[i];
+        const userArg = args.args[carg.n]
+        if (carg.pattern && userArg){
+            const rgx = new RegExp(carg.pattern);
+            if (!rgx.test(userArg)){
+                console.log(`Arg ${carg.n} does not match pattern ${carg.pattern}`);
+                return false;
+            }
+        }
+        if (carg.r && !userArg){
+            console.log('Missing required arg ' + carg.n);
+            return false;
+        }
+    }
+    return true;
+}
+
+main();

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "cloudmason2",
+  "version": "1.0.0",
+  "description": "",
+  "main": "main.js",
+  "files": [
+    "main.js",
+    "commands",
+    ".marketplace"
+  ],
+  "scripts": {
+    "build": "node build.js"
+  },
+  "bin": {
+    "mason2": "./main.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/kai-harvey/cloudmason.git"
+  },
+  "author": "Kai Harvey",
+  "license": "ISC",
+  "dependencies": {
+    "@aws-sdk/client-acm": "^3.418.0",
+    "@aws-sdk/client-auto-scaling": "^3.470.0",
+    "@aws-sdk/client-cloudformation": "^3.418.0",
+    "@aws-sdk/client-ec2": "^3.864.0",
+    "@aws-sdk/client-iam": "^3.864.0",
+    "@aws-sdk/client-marketplace-catalog": "^3.716.0",
+    "@aws-sdk/client-route-53": "^3.425.0",
+    "@aws-sdk/client-s3": "^3.418.0",
+    "@aws-sdk/client-ssm": "^3.421.0",
+    "@aws-sdk/client-sts": "^3.421.0",
+    "adm-zip": "^0.5.10",
+    "ssh2": "^1.16.0",
+    "yaml": "^2.6.1"
+  }
+}