@medplum/cli 2.0.16 → 2.0.18

package/dist/cjs/index.cjs

@@ -1,48 +1,229 @@
 #!/usr/bin/env node
 'use strict';
 
-var commander = require('commander');
 var core = require('@medplum/core');
+var commander = require('commander');
+var dotenv = require('dotenv');
+var clientCloudformation = require('@aws-sdk/client-cloudformation');
+var clientCloudfront = require('@aws-sdk/client-cloudfront');
+var clientEcs = require('@aws-sdk/client-ecs');
+var clientS3 = require('@aws-sdk/client-s3');
+var fastGlob = require('fast-glob');
 var fs = require('fs');
+var fetch$1 = require('node-fetch');
 var os = require('os');
 var path = require('path');
-var dotenv = require('dotenv');
+var promises = require('stream/promises');
+var tar = require('tar');
 var child_process = require('child_process');
 var http = require('http');
 
-class FileSystemStorage extends core.ClientStorage {
-    constructor() {
-        super();
-        this.dirName = path.resolve(os.homedir(), '.medplum');
-        this.fileName = path.resolve(this.dirName, 'credentials');
-    }
-    clear() {
-        this.writeFile({});
-    }
-    getString(key) {
-        return this.readFile()?.[key];
-    }
-    setString(key, value) {
-        const data = this.readFile() || {};
-        if (value) {
-            data[key] = value;
+const clientId = 'medplum-cli';
+const redirectUri = 'http://localhost:9615';
+const login = new commander.Command('login');
+const whoami = new commander.Command('whoami');
+login.action(async () => {
+    await startLogin(exports.medplum);
+});
+whoami.action(() => {
+    printMe(exports.medplum);
+});
+async function startLogin(medplum) {
+    await startWebServer(medplum);
+    const loginUrl = new URL('/oauth2/authorize', medplum.getBaseUrl());
+    loginUrl.searchParams.set('client_id', clientId);
+    loginUrl.searchParams.set('redirect_uri', redirectUri);
+    loginUrl.searchParams.set('scope', 'openid');
+    loginUrl.searchParams.set('response_type', 'code');
+    loginUrl.searchParams.set('prompt', 'login');
+    await openBrowser(loginUrl.toString());
+}
+async function startWebServer(medplum) {
+    const server = http.createServer(async (req, res) => {
+        const url = new URL(req.url, 'http://localhost:9615');
+        const code = url.searchParams.get('code');
+        if (url.pathname === '/' && code) {
+            try {
+                const profile = await medplum.processCode(code, { clientId, redirectUri });
+                res.writeHead(200, { 'Content-Type': 'text/plain' });
+                res.end(`Signed in as ${core.getDisplayString(profile)}. You may close this window.`);
+            }
+            catch (err) {
+                res.writeHead(400, { 'Content-Type': 'text/plain' });
+                res.end(`Error: ${core.normalizeErrorString(err)}`);
+            }
+            finally {
+                server.close();
+            }
         }
         else {
-            delete data[key];
+            res.writeHead(404, { 'Content-Type': 'text/plain' });
+            res.end('Not found');
         }
-        this.writeFile(data);
+    }).listen(9615);
+}
+/**
+ * Opens a web browser to the specified URL.
+ * See: https://hasinthaindrajee.medium.com/browser-sso-for-cli-applications-b0be743fa656
+ * @param url The URL to open.
+ */
+async function openBrowser(url) {
+    const os$1 = os.platform();
+    let cmd = undefined;
+    switch (os$1) {
+        case 'openbsd':
+        case 'linux':
+            cmd = `xdg-open '${url}'`;
+            break;
+        case 'darwin':
+            cmd = `open '${url}'`;
+            break;
+        case 'win32':
+            cmd = `cmd /c start "" "${url}"`;
+            break;
+        default:
+            throw new Error('Unsupported platform: ' + os$1);
     }
-    readFile() {
-        if (fs.existsSync(this.fileName)) {
-            return JSON.parse(fs.readFileSync(this.fileName, 'utf8'));
+    child_process.exec(cmd);
+}
+/**
+ * Prints the current user and project.
+ * @param medplum The Medplum client.
+ */
+function printMe(medplum) {
+    const loginState = medplum.getActiveLogin();
+    if (loginState) {
+        console.log(`Server:  ${medplum.getBaseUrl()}`);
+        console.log(`Profile: ${loginState.profile?.display} (${loginState.profile?.reference})`);
+        console.log(`Project: ${loginState.project?.display} (${loginState.project?.reference})`);
+    }
+    else {
+        console.log('Not logged in');
+    }
+}
+
+const cloudFormationClient = new clientCloudformation.CloudFormationClient({});
+const cloudFrontClient = new clientCloudfront.CloudFrontClient({});
+const ecsClient = new clientEcs.ECSClient({});
+const s3Client = new clientS3.S3Client({});
+const tagKey = 'medplum:environment';
+/**
+ * Returns a list of all AWS CloudFormation stacks (both Medplum and non-Medplum).
+ * @returns List of AWS CloudFormation stacks.
+ */
+async function getAllStacks() {
+    const listResult = await cloudFormationClient.send(new clientCloudformation.ListStacksCommand({}));
+    return (listResult.StackSummaries?.filter((s) => s.StackName && s.StackStatus !== 'DELETE_COMPLETE') || []);
+}
+/**
+ * Returns Medplum stack details for the given tag.
+ * @param tag The Medplum stack tag.
+ * @returns The Medplum stack details.
+ */
+async function getStackByTag(tag) {
+    const stackSummaries = await getAllStacks();
+    for (const stackSummary of stackSummaries) {
+        const stackName = stackSummary.StackName;
+        const details = await getStackDetails(stackName);
+        if (details?.tag === tag) {
+            return details;
         }
+    }
+    return undefined;
+}
+/**
+ * Returns Medplum stack details for the given stack name.
+ * @param stackName The CloudFormation stack name.
+ * @returns The Medplum stack details.
+ */
+async function getStackDetails(stackName) {
+    const describeStacksCommand = new clientCloudformation.DescribeStacksCommand({ StackName: stackName });
+    const stackDetails = await cloudFormationClient.send(describeStacksCommand);
+    const stack = stackDetails?.Stacks?.[0];
+    const medplumTag = stack?.Tags?.find((tag) => tag.Key === tagKey);
+    if (!medplumTag) {
         return undefined;
     }
-    writeFile(data) {
-        if (!fs.existsSync(this.dirName)) {
-            fs.mkdirSync(this.dirName);
+    const stackResources = await cloudFormationClient.send(new clientCloudformation.DescribeStackResourcesCommand({ StackName: stackName }));
+    if (!stackResources.StackResources) {
+        return undefined;
+    }
+    const result = {
+        stack: stack,
+        tag: medplumTag.Value,
+    };
+    for (const resource of stackResources.StackResources) {
+        if (resource.ResourceType === 'AWS::ECS::Cluster') {
+            result.ecsCluster = resource;
+        }
+        else if (resource.ResourceType === 'AWS::ECS::Service') {
+            result.ecsService = resource;
+        }
+        else if (resource.ResourceType === 'AWS::S3::Bucket' &&
+            resource.LogicalResourceId?.startsWith('FrontEndAppBucket')) {
+            result.appBucket = resource;
+        }
+        else if (resource.ResourceType === 'AWS::S3::Bucket' &&
+            resource.LogicalResourceId?.startsWith('StorageStorageBucket')) {
+            result.storageBucket = resource;
+        }
+        else if (resource.ResourceType === 'AWS::CloudFront::Distribution' &&
+            resource.LogicalResourceId?.startsWith('FrontEndAppDistribution')) {
+            result.appDistribution = resource;
         }
-        fs.writeFileSync(this.fileName, JSON.stringify(data, null, 2), 'utf8');
+    }
+    return result;
+}
+/**
+ * Prints the given Medplum stack details to stdout.
+ * @param details The Medplum stack details.
+ */
+function printStackDetails(details) {
+    console.log(`Medplum Tag:     ${details.tag}`);
+    console.log(`Stack Name:      ${details.stack.StackName}`);
+    console.log(`Stack ID:        ${details.stack.StackId}`);
+    console.log(`Status:          ${details.stack.StackStatus}`);
+    console.log(`ECS Cluster:     ${details.ecsCluster?.PhysicalResourceId}`);
+    console.log(`ECS Service:     ${getEcsServiceName(details.ecsService)}`);
+    console.log(`App Bucket:      ${details.appBucket?.PhysicalResourceId}`);
+    console.log(`Storage Bucket:  ${details.storageBucket?.PhysicalResourceId}`);
+}
+/**
+ * Parses the ECS service name from the given AWS ECS service resource.
+ * @param resource The AWS ECS service resource.
+ * @returns The ECS service name.
+ */
+function getEcsServiceName(resource) {
+    return resource?.PhysicalResourceId?.split('/')?.pop() || '';
+}
+
+/**
+ * The AWS "describe" command prints details about a Medplum CloudFormation stack.
+ *
+ * @param tag The Medplum stack tag.
+ */
+async function describeStacksCommand(tag) {
+    const details = await getStackByTag(tag);
+    if (!details) {
+        console.log('Stack not found');
+        return;
+    }
+    printStackDetails(details);
+}
+
+/**
+ * The AWS "list" command prints summary details about all Medplum CloudFormation stacks.
+ */
+async function listStacksCommand() {
+    const stackSummaries = await getAllStacks();
+    for (const stackSummary of stackSummaries) {
+        const stackName = stackSummary.StackName;
+        const details = await getStackDetails(stackName);
+        if (!details) {
+            continue;
+        }
+        printStackDetails(details);
+        console.log('');
     }
 }
 
@@ -125,8 +306,9 @@ function readBotConfigs(botName) {
     }
     return botConfigs;
 }
-function readConfig() {
-    const content = readFileContents('medplum.config.json');
+function readConfig(tagName) {
+    const fileName = tagName ? `medplum.${tagName}.config.json` : 'medplum.config.json';
+    const content = readFileContents(fileName);
     if (!content) {
         return undefined;
     }
@@ -150,6 +332,265 @@ function addBotToConfig(botConfig) {
 function escapeRegex(str) {
     return str.replace(/[/\-\\^$*+?.()|[\]{}]/g, '\\$&');
 }
+/**
+ * Creates a safe tar extractor that limits the number of files and total size.
+ *
+ * Expanding archive files without controlling resource consumption is security-sensitive
+ *
+ * See: https://sonarcloud.io/organizations/medplum/rules?open=typescript%3AS5042&rule_key=typescript%3AS5042
+ *
+ * @param destinationDir The destination directory where all files will be extracted.
+ * @returns A tar file extractor.
+ */
+function safeTarExtractor(destinationDir) {
+    const MAX_FILES = 100;
+    const MAX_SIZE = 10 * 1024 * 1024; // 10 MB
+    let fileCount = 0;
+    let totalSize = 0;
+    return tar.x({
+        cwd: destinationDir,
+        filter: (_path, entry) => {
+            fileCount++;
+            if (fileCount > MAX_FILES) {
+                throw new Error('Tar extractor reached max number of files');
+            }
+            totalSize += entry.size;
+            if (totalSize > MAX_SIZE) {
+                throw new Error('Tar extractor reached max size');
+            }
+            return true;
+        },
+    });
+}
+
+/**
+ * The AWS "update-app" command updates the Medplum app in a Medplum CloudFormation stack to the latest version.
+ * @param tag The Medplum stack tag.
+ */
+async function updateAppCommand(tag) {
+    const config = readConfig(tag);
+    if (!config) {
+        console.log('Config not found');
+        return;
+    }
+    const details = await getStackByTag(tag);
+    if (!details) {
+        console.log('Stack not found');
+        return;
+    }
+    const appBucket = details.appBucket;
+    if (!appBucket) {
+        console.log('App bucket not found');
+        return;
+    }
+    const tmpDir = await downloadNpmPackage('@medplum/app', 'latest');
+    // Replace variables in the app
+    replaceVariables(tmpDir, {
+        MEDPLUM_BASE_URL: config.baseUrl,
+        MEDPLUM_CLIENT_ID: config.clientId || '',
+        GOOGLE_CLIENT_ID: config.googleClientId || '',
+        RECAPTCHA_SITE_KEY: config.recaptchaSiteKey || '',
+        MEDPLUM_REGISTER_ENABLED: config.registerEnabled ? 'true' : 'false',
+    });
+    // Upload the app to S3 with correct content-type and cache-control
+    await uploadAppToS3(tmpDir, appBucket.PhysicalResourceId);
+    // Create a CloudFront invalidation to clear any cached resources
+    if (details.appDistribution?.PhysicalResourceId) {
+        await createInvalidation(details.appDistribution.PhysicalResourceId);
+    }
+    console.log('Done');
+}
+/**
+ * Returns NPM package metadata for a given package name.
+ * See: https://github.com/npm/registry/blob/master/docs/REGISTRY-API.md#getpackageversion
+ * @param packageName The npm package name.
+ */
+async function getNpmPackageMetadata(packageName, version) {
+    const url = `https://registry.npmjs.org/${packageName}/${version}`;
+    const response = await fetch$1(url);
+    return response.json();
+}
+/**
+ * Downloads and extracts an NPM package.
+ * @param packageName The NPM package name.
+ * @param version The NPM package version or "latest".
+ * @returns Path to temporary directory where the package was downloaded and extracted.
+ */
+async function downloadNpmPackage(packageName, version) {
+    const packageMetadata = await getNpmPackageMetadata(packageName, version);
+    const tarballUrl = packageMetadata.dist.tarball;
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tarball-'));
+    try {
+        const response = await fetch$1(tarballUrl);
+        const extractor = safeTarExtractor(tmpDir);
+        await promises.pipeline(response.body, extractor);
+        return path.join(tmpDir, 'package', 'dist');
+    }
+    catch (error) {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+        throw error;
+    }
+}
+/**
+ * Replaces variables in all JS files in the given folder.
+ * @param folderName The folder name of the files.
+ * @param replacements The collection of variable placeholders and replacements.
+ */
+function replaceVariables(folderName, replacements) {
+    for (const item of fs.readdirSync(folderName, { withFileTypes: true })) {
+        const itemPath = path.join(folderName, item.name);
+        if (item.isDirectory()) {
+            replaceVariables(itemPath, replacements);
+        }
+        else if (item.isFile() && itemPath.endsWith('.js')) {
+            replaceVariablesInFile(itemPath, replacements);
+        }
+    }
+}
+/**
+ * Replaces variables in the JS file.
+ * @param fileName The file name.
+ * @param replacements The collection of variable placeholders and replacements.
+ */
+function replaceVariablesInFile(fileName, replacements) {
+    let contents = fs.readFileSync(fileName, 'utf-8');
+    for (const [placeholder, replacement] of Object.entries(replacements)) {
+        contents = contents.replaceAll(`process.env.${placeholder}`, `'${replacement}'`);
+    }
+    fs.writeFileSync(fileName, contents);
+}
+/**
+ * Uploads the app to S3.
+ * Ensures correct content-type and cache-control for each file.
+ * @param tmpDir The temporary directory where the app is located.
+ * @param bucketName The destination S3 bucket name.
+ */
+async function uploadAppToS3(tmpDir, bucketName) {
+    // Manually iterate and upload files
+    // Automatic content-type detection is not reliable on Microsoft Windows
+    // So we explicitly set content-type
+    const uploadPatterns = [
+        // Cached
+        // These files generally have a hash, so they can be cached forever
+        // It is important to upload them first to avoid broken references from index.html
+        ['css/**/*.css', 'text/css', true],
+        ['css/**/*.css.map', 'application/json', true],
+        ['img/**/*.png', 'image/png', true],
+        ['img/**/*.svg', 'image/svg+xml', true],
+        ['js/**/*.js', 'application/javascript', true],
+        ['js/**/*.js.map', 'application/json', true],
+        ['js/**/*.txt', 'text/plain', true],
+        ['favicon.ico', 'image/vnd.microsoft.icon', true],
+        ['robots.txt', 'text/plain', true],
+        ['workbox-*.js', 'application/javascript', true],
+        ['workbox-*.js.map', 'application/json', true],
+        // Not cached
+        ['manifest.webmanifest', 'application/manifest+json', false],
+        ['service-worker.js', 'application/javascript', false],
+        ['service-worker.js.map', 'application/json', false],
+        ['index.html', 'text/html', false],
+    ];
+    for (const uploadPattern of uploadPatterns) {
+        await uploadFolderToS3({
+            rootDir: tmpDir,
+            bucketName,
+            fileNamePattern: uploadPattern[0],
+            contentType: uploadPattern[1],
+            cached: uploadPattern[2],
+        });
+    }
+}
+/**
+ * Uploads a directory of files to S3.
+ * @param options The upload options such as bucket name, content type, and cache control.
+ */
+async function uploadFolderToS3(options) {
+    const items = fastGlob.sync(options.fileNamePattern, { cwd: options.rootDir });
+    for (const item of items) {
+        await uploadFileToS3(path.join(options.rootDir, item), options);
+    }
+}
+/**
+ * Uploads a file to S3.
+ * @param filePath The file path.
+ * @param options The upload options such as bucket name, content type, and cache control.
+ */
+async function uploadFileToS3(filePath, options) {
+    const fileStream = fs.createReadStream(filePath);
+    const s3Key = filePath
+        .substring(options.rootDir.length + 1)
+        .split(path.sep)
+        .join('/');
+    const putObjectParams = {
+        Bucket: options.bucketName,
+        Key: s3Key,
+        Body: fileStream,
+        ContentType: options.contentType,
+        CacheControl: options.cached ? 'public, max-age=31536000' : 'no-cache, no-store, must-revalidate',
+    };
+    console.log(`Uploading ${s3Key} to ${options.bucketName}...`);
+    await s3Client.send(new clientS3.PutObjectCommand(putObjectParams));
+}
+/**
+ * Creates a CloudFront invalidation to clear the cache for all files.
+ * This is not strictly necessary, but it helps to ensure that the latest version of the app is served.
+ * In a perfect world, every deploy is clean, and hashed resources should be cached forever.
+ * However, we do not recalculate hashes after variable replacements.
+ * So if variables change, we need to invalidate the cache.
+ * @param distributionId The CloudFront distribution ID.
+ */
+async function createInvalidation(distributionId) {
+    const response = await cloudFrontClient.send(new clientCloudfront.CreateInvalidationCommand({
+        DistributionId: distributionId,
+        InvalidationBatch: {
+            CallerReference: `invalidate-all-${Date.now()}`,
+            Paths: {
+                Quantity: 1,
+                Items: ['/*'],
+            },
+        },
+    }));
+    console.log(`Created invalidation with ID: ${response.Invalidation?.Id}`);
+}
+
+/**
+ * The AWS "update-server" command updates the Medplum server in a Medplum CloudFormation stack.
+ * @param tag The Medplum stack tag.
+ * @returns
+ */
+async function updateServerCommand(tag) {
+    const details = await getStackByTag(tag);
+    if (!details) {
+        console.log('Stack not found');
+        return;
+    }
+    const ecsCluster = details.ecsCluster?.PhysicalResourceId;
+    if (!ecsCluster) {
+        console.log('ECS Cluster not found');
+        return;
+    }
+    const ecsService = getEcsServiceName(details.ecsService);
+    if (!ecsService) {
+        console.log('ECS Service not found');
+        return;
+    }
+    await ecsClient.send(new clientEcs.UpdateServiceCommand({
+        cluster: ecsCluster,
+        service: ecsService,
+        forceNewDeployment: true,
+    }));
+    console.log(`Service "${ecsService}" updated successfully.`);
+}
+
+const aws = new commander.Command('aws').description('Commands to manage AWS resources');
+aws.command('list').description('List Medplum AWS CloudFormation stacks').action(listStacksCommand);
+aws
+    .command('describe')
+    .description('Describe a Medplum AWS CloudFormation stack by tag')
+    .argument('<tag>')
+    .action(describeStacksCommand);
+aws.command('update-server').description('Update the server image').argument('<tag>').action(updateServerCommand);
+aws.command('update-app').description('Update the app site').argument('<tag>').action(updateAppCommand);
 
 const bot = new commander.Command('bot');
 // Commands to deprecate
@@ -208,86 +649,86 @@ createBotDeprecate
     await createBot(exports.medplum, [botName, projectId, sourceFile, distFile]);
 });
 
-const clientId = 'medplum-cli';
-const redirectUri = 'http://localhost:9615';
-const login = new commander.Command('login');
-const whoami = new commander.Command('whoami');
-login.action(async () => {
-    await startLogin(exports.medplum);
-});
-whoami.action(() => {
-    printMe(exports.medplum);
+const project = new commander.Command('project');
+project
+    .command('list')
+    .description('List of current projects')
+    .action(async () => {
+    projectList(exports.medplum);
 });
-async function startLogin(medplum) {
-    await startWebServer(medplum);
-    const loginUrl = new URL('/oauth2/authorize', medplum.getBaseUrl());
-    loginUrl.searchParams.set('client_id', clientId);
-    loginUrl.searchParams.set('redirect_uri', redirectUri);
-    loginUrl.searchParams.set('scope', 'openid');
-    loginUrl.searchParams.set('response_type', 'code');
-    await openBrowser(loginUrl.toString());
-}
-async function startWebServer(medplum) {
-    const server = http.createServer(async (req, res) => {
-        const url = new URL(req.url, 'http://localhost:9615');
-        const code = url.searchParams.get('code');
-        if (url.pathname === '/' && code) {
-            try {
-                const profile = await medplum.processCode(code, { clientId, redirectUri });
-                res.writeHead(200, { 'Content-Type': 'text/plain' });
-                res.end(`Signed in as ${core.getDisplayString(profile)}. You may close this window.`);
-            }
-            catch (err) {
-                res.writeHead(400, { 'Content-Type': 'text/plain' });
-                res.end(`Error: ${core.normalizeErrorString(err)}`);
-            }
-            finally {
-                server.close();
-            }
-        }
-        else {
-            res.writeHead(404, { 'Content-Type': 'text/plain' });
-            res.end('Not found');
-        }
-    }).listen(9615);
+function projectList(medplum) {
+    const logins = medplum.getLogins();
+    const projects = logins
+        .map((login) => `${login.project.display} (${login.project.reference})`)
+        .join('\n\n');
+    console.log(projects);
 }
-/**
- * Opens a web browser to the specified URL.
- * See: https://hasinthaindrajee.medium.com/browser-sso-for-cli-applications-b0be743fa656
- * @param url The URL to open.
- */
-async function openBrowser(url) {
-    const os$1 = os.platform();
-    let cmd = undefined;
-    switch (os$1) {
-        case 'openbsd':
-        case 'linux':
-            cmd = `xdg-open '${url}'`;
-            break;
-        case 'darwin':
-            cmd = `open '${url}'`;
-            break;
-        case 'win32':
-            cmd = `cmd /c start "" "${url}"`;
-            break;
-        default:
-            throw new Error('Unsupported platform: ' + os$1);
+project
+    .command('current')
+    .description('Project you are currently on')
+    .action(() => {
+    const login = exports.medplum.getActiveLogin();
+    if (!login) {
+        throw new Error('Unauthenticated: run `npx medplum login` to login');
     }
-    child_process.exec(cmd);
-}
-/**
- * Prints the current user and project.
- * @param medplum The Medplum client.
- */
-function printMe(medplum) {
-    const loginState = medplum.getActiveLogin();
-    if (loginState) {
-        console.log(`Server:  ${medplum.getBaseUrl()}`);
-        console.log(`Profile: ${loginState.profile?.display} (${loginState.profile?.reference})`);
-        console.log(`Project: ${loginState.project?.display} (${loginState.project?.reference})`);
+    console.log(`${login.project.display} (${login.project.reference})`);
+});
+project
+    .command('switch')
+    .description('Switching to another project from the current one')
+    .argument('<projectId>')
+    .action(async (projectId) => {
+    await switchProject(exports.medplum, projectId);
+});
+project
+    .command('invite')
+    .description('Invite a member to your current project (run npx medplum project current to confirm)')
+    .arguments('<firstName> <lastName> <email>')
+    .option('--send-email', 'If you want to send the email when inviting the user')
+    .option('--admin', 'If the user you are inviting is an admin')
+    .addOption(new commander.Option('-r, --role <role>', 'Role of user')
+    .choices(['Practitioner', 'Patient', 'RelatedPerson'])
+    .default('Practitioner'))
+    .action(async (firstName, lastName, email, options) => {
+    const login = exports.medplum.getActiveLogin();
+    if (!login) {
+        throw new Error('Unauthenticated: run `npx medplum login` to login');
+    }
+    if (!login.project?.reference) {
+        throw new Error('No current project to invite user to');
+    }
+    const projectId = login.project.reference.split('/')[1];
+    const inviteBody = {
+        resourceType: options.role,
+        firstName,
+        lastName,
+        email,
+        sendEmail: !!options.sendEmail,
+        admin: !!options.admin,
+    };
+    await inviteUser(projectId, inviteBody);
+});
+async function switchProject(medplum, projectId) {
+    const logins = medplum.getLogins();
+    const login = logins.find((login) => login.project?.reference?.includes(projectId));
+    if (!login) {
+        console.log(`Error: project ${projectId} not found. Make sure you are added as a user to this project`);
     }
     else {
-        console.log('Not logged in');
+        await medplum.setActiveLogin(login);
+        console.log(`Switched to project ${projectId}\n`);
+    }
+}
+async function inviteUser(projectId, inviteBody) {
+    try {
+        await exports.medplum.invite(projectId, inviteBody);
+        if (inviteBody.sendEmail) {
+            console.log('Email sent');
+        }
+        console.log('See your users at https://app.medplum.com/admin/users');
+    }
+    catch (err) {
+        console.log('Error while sending invite ' + err);
     }
 }
 
@@ -303,17 +744,12 @@ get
     .argument('<url>', 'Resource/$id')
     .option('--as-transaction', 'Print out the bundle as a transaction type')
     .action(async (url, options) => {
-    try {
-        const response = await exports.medplum.get(cleanUrl(url));
-        if (options.asTransaction) {
-            prettyPrint(core.convertToTransactionBundle(response));
-        }
-        else {
-            prettyPrint(response);
-        }
+    const response = await exports.medplum.get(cleanUrl(url));
+    if (options.asTransaction) {
+        prettyPrint(core.convertToTransactionBundle(response));
     }
-    catch (err) {
-        console.log(err);
+    else {
+        prettyPrint(response);
     }
 });
 patch.arguments('<url> <body>').action(async (url, body) => {
@@ -346,46 +782,39 @@ function cleanUrl(input) {
     return 'fhir/R4/' + input;
 }
 
-const project = new commander.Command('project');
-project
-    .command('list')
-    .description('List of current projects')
-    .action(async () => {
-    projectList(exports.medplum);
-});
-function projectList(medplum) {
-    const logins = medplum.getLogins();
-    const projects = logins
-        .map((login) => `${login.project.display} (${login.project.reference})`)
-        .join('\n\n');
-    console.log(projects);
-}
-project
-    .command('current')
-    .description('Project you are currently on')
-    .action(() => {
-    const login = exports.medplum.getActiveLogin();
-    if (!login) {
-        throw new Error('Unauthenticated: run `npx medplum login` to login');
+class FileSystemStorage extends core.ClientStorage {
+    constructor() {
+        super();
+        this.dirName = path.resolve(os.homedir(), '.medplum');
+        this.fileName = path.resolve(this.dirName, 'credentials');
     }
-    console.log(`${login.project.display} (${login.project.reference})`);
-});
-project
-    .command('switch')
-    .description('Switching to another project from the current one')
-    .argument('<projectId>')
-    .action(async (projectId) => {
-    await switchProject(exports.medplum, projectId);
-});
-async function switchProject(medplum, projectId) {
-    const logins = medplum.getLogins();
-    const login = logins.find((login) => login.project?.reference?.includes(projectId));
-    if (!login) {
-        console.log(`Error: project ${projectId} not found. Make sure you are added as a user to this project`);
+    clear() {
+        this.writeFile({});
     }
-    else {
-        await medplum.setActiveLogin(login);
-        console.log(`Switched to project ${projectId}\n`);
+    getString(key) {
+        return this.readFile()?.[key];
+    }
+    setString(key, value) {
+        const data = this.readFile() || {};
+        if (value) {
+            data[key] = value;
+        }
+        else {
+            delete data[key];
+        }
+        this.writeFile(data);
+    }
+    readFile() {
+        if (fs.existsSync(this.fileName)) {
+            return JSON.parse(fs.readFileSync(this.fileName, 'utf8'));
+        }
+        return undefined;
+    }
+    writeFile(data) {
+        if (!fs.existsSync(this.dirName)) {
+            fs.mkdirSync(this.dirName);
+        }
+        fs.writeFileSync(this.fileName, JSON.stringify(data, null, 2), 'utf8');
     }
 }
 
@@ -400,7 +829,7 @@ async function main(medplumClient, argv) {
     }
     try {
         const index = new commander.Command('medplum').description('Command to access Medplum CLI');
-        index.version('0.1.0');
+        index.version(core.MEDPLUM_VERSION);
         // Auth commands
         index.addCommand(login);
         index.addCommand(whoami);
@@ -418,6 +847,8 @@ async function main(medplumClient, argv) {
         index.addCommand(saveBotDeprecate);
         index.addCommand(deployBotDeprecate);
         index.addCommand(createBotDeprecate);
+        // AWS commands
+        index.addCommand(aws);
         await index.parseAsync(argv);
     }
     catch (err) {
@@ -427,9 +858,17 @@ async function main(medplumClient, argv) {
 if (require.main === module) {
     dotenv.config();
     const baseUrl = process.env['MEDPLUM_BASE_URL'] || 'https://api.medplum.com/';
-    const medplumClient = new core.MedplumClient({ fetch, baseUrl, storage: new FileSystemStorage() });
+    const medplumClient = new core.MedplumClient({
+        fetch,
+        baseUrl,
+        storage: new FileSystemStorage(),
+        onUnauthenticated: onUnauthenticated,
+    });
     main(medplumClient, process.argv).catch((err) => console.error('Unhandled error:', err));
 }
+function onUnauthenticated() {
+    console.log('Unauthenticated: run `npx medplum login` to sign in');
+}
 
 exports.main = main;
 //# sourceMappingURL=index.cjs.map