@auxx/sdk 0.0.5 → 0.0.6

package/lib/api/api.js

@@ -1,7 +1,7 @@
 import { complete, errored } from '../errors.js';
 import { Fetcher } from './fetcher.js';
 import { AUTH_API } from '../env.js';
-import { appInfoSchema, completeBundleUploadSchema, createDevVersionSchema, createVersionSchema, fetchAppLogsResponseSchema, installationSchema, listAppsResponseSchema, listDevOrganizationsResponseSchema, oidcUserInfoSchema, TEST_APP_INFO, TEST_ORGANIZATIONS, tokenResponseSchema, versionsSchema, whoamiSchema, } from './schemas.js';
+import { appInfoSchema, checkBundlesResponseSchema, confirmBundlesResponseSchema, createDeploymentResponseSchema, fetchAppLogsResponseSchema, installationSchema, listAppsResponseSchema, listDeploymentsResponseSchema, listDevOrganizationsResponseSchema, oidcUserInfoSchema, TEST_APP_INFO, TEST_ORGANIZATIONS, tokenResponseSchema, whoamiSchema, } from './schemas.js';
 class ApiImpl {
     fetcher;
     constructor() {
@@ -101,62 +101,62 @@ class ApiImpl {
         }
         return complete(result.value.organizations);
     }
-    async createVersion({ appId, major, cliVersion, }) {
+    async checkBundles({ appId, clientSha, serverSha, }) {
         const result = await this.fetcher.post({
-            path: `/api/v1/apps/${appId}/prod-versions`,
-            body: {
-                major,
-                cli_version: cliVersion,
-            },
-            schema: createVersionSchema,
+            path: `/api/v1/apps/${appId}/bundles/check`,
+            body: { clientSha, serverSha },
+            schema: checkBundlesResponseSchema,
         });
         if (!result.success) {
-            return errored({ code: 'CREATE_VERSION_ERROR', error: result.error });
+            return errored({ code: 'CHECK_BUNDLES_ERROR', error: result.error });
         }
         return complete(result.value);
     }
-    async completeBundleUpload({ appId, versionId, bundleId, bundleSha, settingsSchema, }) {
+    async confirmBundles({ appId, clientSha, serverSha, }) {
         const result = await this.fetcher.post({
-            path: `/api/v1/apps/${appId}/dev-versions/${versionId}/bundles/${bundleId}/complete`,
-            body: {
-                bundle_sha: bundleSha,
-                settings_schema: settingsSchema,
-            },
-            schema: completeBundleUploadSchema,
+            path: `/api/v1/apps/${appId}/bundles/confirm`,
+            body: { clientSha, serverSha },
+            schema: confirmBundlesResponseSchema,
         });
         if (!result.success) {
-            return errored({ code: 'COMPLETE_BUNDLE_UPLOAD_ERROR', error: result.error });
+            return errored({ code: 'CONFIRM_BUNDLES_ERROR', error: result.error });
         }
-        return complete(undefined);
+        return complete(result.value);
     }
-    async completeProdBundleUpload({ appId, versionId, bundleId, bundleSha, settingsSchema, }) {
+    async createDeployment({ appId, clientBundleSha, serverBundleSha, deploymentType, settingsSchema, targetOrganizationId, environmentVariables, version, metadata, }) {
         const result = await this.fetcher.post({
-            path: `/api/v1/apps/${appId}/prod-versions/${versionId}/bundles/${bundleId}/complete`,
+            path: `/api/v1/apps/${appId}/deployments`,
             body: {
-                bundle_sha: bundleSha,
-                settings_schema: settingsSchema,
+                clientBundleSha,
+                serverBundleSha,
+                deploymentType,
+                settingsSchema,
+                targetOrganizationId,
+                environmentVariables,
+                version,
+                metadata,
             },
-            schema: completeBundleUploadSchema,
+            schema: createDeploymentResponseSchema,
         });
         if (!result.success) {
-            return errored({ code: 'COMPLETE_PROD_BUNDLE_UPLOAD_ERROR', error: result.error });
+            return errored({ code: 'CREATE_DEPLOYMENT_ERROR', error: result.error });
         }
-        return complete(undefined);
+        return complete(result.value);
     }
-    async createDevVersion({ appId, cliVersion, targetOrganizationId, environmentVariables, }) {
-        const result = await this.fetcher.post({
-            path: `/api/v1/apps/${appId}/dev-versions`,
-            body: {
-                target_organization_id: targetOrganizationId,
-                environment_variables: environmentVariables,
-                cli_version: cliVersion,
-            },
-            schema: createDevVersionSchema,
+    async listDeployments({ appId, type }) {
+        const params = new URLSearchParams();
+        if (type)
+            params.append('type', type);
+        const queryString = params.toString();
+        const path = `/api/v1/apps/${appId}/deployments${queryString ? `?${queryString}` : ''}`;
+        const result = await this.fetcher.get({
+            path,
+            schema: listDeploymentsResponseSchema,
         });
         if (!result.success) {
-            return errored({ code: 'CREATE_DEV_VERSION_ERROR', error: result.error });
+            return errored({ code: 'LIST_DEPLOYMENTS_ERROR', error: result.error });
         }
-        return complete(result.value);
+        return complete(result.value.deployments);
     }
     async fetchInstallation({ appId, organizationId }) {
         const result = await this.fetcher.get({
@@ -171,16 +171,6 @@ class ApiImpl {
         }
         return complete(result);
     }
-    async fetchVersions(appId) {
-        const result = await this.fetcher.get({
-            path: `/api/v1/apps/${appId}/prod-versions`,
-            schema: versionsSchema,
-        });
-        if (!result.success) {
-            return errored({ code: 'FETCH_VERSIONS_ERROR', error: result.error });
-        }
-        return complete(result.value.app_prod_versions);
-    }
     async fetchAppLogs({ organizationHandle, appSlug, cursor, limit = 100, }) {
         const params = new URLSearchParams();
         if (cursor)

package/lib/api/schemas.js

@@ -53,29 +53,35 @@ export const listAppsResponseSchema = z.object({
         apps: z.array(appDataSchema),
     }),
 });
-const bundleSchema = z.object({
-    id: z.string(),
-    clientBundleUploadUrl: z.string().url(),
-    serverBundleUploadUrl: z.string().url(),
-    bundleSha: z.string().optional(),
+const bundleCheckItemSchema = z.object({
+    exists: z.boolean(),
+    bundleId: z.string(),
+    uploadUrl: z.string().nullable(),
 });
-export const completeBundleRequestSchema = z.object({
-    bundleSha: z.string(),
+export const checkBundlesResponseSchema = z.object({
+    client: bundleCheckItemSchema,
+    server: bundleCheckItemSchema,
 });
-export const completeBundleUploadSchema = z.object({
+export const confirmBundlesResponseSchema = z.object({
     success: z.boolean(),
 });
-export const versionSchema = z.object({
-    major: z.number(),
-    minor: z.number(),
-    created_at: z.string(),
-    released_at: z.string().nullable().optional(),
-    is_published: z.boolean(),
-    num_installations: z.number(),
-    publication_status: z.enum(['private', 'in-review', 'published', 'rejected', 'unpublished']),
+export const createDeploymentResponseSchema = z.object({
+    deploymentId: z.string(),
+    version: z.string().nullable(),
 });
-export const versionsSchema = z.object({
-    app_prod_versions: z.array(versionSchema),
+export const deploymentSchema = z.object({
+    id: z.string(),
+    deploymentType: z.enum(['development', 'production']),
+    version: z.string().nullable(),
+    status: z.string(),
+    clientBundleSha: z.string(),
+    serverBundleSha: z.string(),
+    settingsSchema: z.unknown().nullable(),
+    metadata: z.unknown().nullable(),
+    createdAt: z.string(),
+});
+export const listDeploymentsResponseSchema = z.object({
+    deployments: z.array(deploymentSchema),
 });
 export const organizationResponseSchema = z.object({
     id: z.string(),
@@ -86,20 +92,6 @@ export const organizationResponseSchema = z.object({
 export const listDevOrganizationsResponseSchema = z.object({
     organizations: z.array(organizationResponseSchema),
 });
-export const createVersionSchema = z.object({
-    versionId: z.string(),
-    appId: z.string(),
-    major: z.number(),
-    minor: z.number(),
-    bundle: bundleSchema,
-});
-export const createDevVersionSchema = z.object({
-    versionId: z.string(),
-    appId: z.string(),
-    major: z.number(),
-    minor: z.number(),
-    bundle: bundleSchema,
-});
 export const installationSchema = z.object({
     appId: z.string(),
     organizationId: z.string(),

package/lib/commands/dev/boot.js

@@ -1,4 +1,3 @@
-import { api } from '../../api/api.js';
 import { isErrored } from '../../errors.js';
 import { printCliVersionError, printDetermineOrganizationError, printFetcherError, printPackageJsonError, } from '../../print-errors.js';
 import { determineOrganization } from '../../spinners/determine-organization.spinner.js';
@@ -32,24 +31,11 @@ export async function boot({ organizationSlug }) {
         process.exit(1);
     }
     const cliVersion = cliVersionResult.value;
-    const devVersionResult = await api.createDevVersion({
-        appId: appInfo.id,
-        cliVersion,
-        targetOrganizationId: organization.id,
-        environmentVariables,
-    });
-    if (isErrored(devVersionResult)) {
-        printFetcherError('Error creating dev version', devVersionResult.error);
-        process.exit(1);
-    }
-    const devVersion = devVersionResult.value;
     return {
         appId: appInfo.id,
         appSlug,
-        devVersionId: devVersion.versionId,
-        bundleId: devVersion.bundle.id,
-        clientBundleUploadUrl: devVersion.bundle.clientBundleUploadUrl,
-        serverBundleUploadUrl: devVersion.bundle.serverBundleUploadUrl,
         organization,
+        environmentVariables,
+        cliVersion,
     };
 }

package/lib/commands/dev/onboarding.js

@@ -11,6 +11,7 @@ export function onboarding({ appId, appSlug, organization }) {
         open(`${APP_URL}/app/settings/apps/${appSlug}`);
     });
     const poll = async () => {
+        await new Promise((resolve) => setTimeout(resolve, 15_000));
         const installationResult = await api.fetchInstallation({
             appId,
             organizationId: organization.id,

package/lib/commands/dev/upload.js

@@ -2,32 +2,50 @@ import chalk from 'chalk';
 import notifier from 'node-notifier';
 import { api } from '../../api/api.js';
 import { combineAsync, complete, isErrored } from '../../errors.js';
-import { calculateBundleShas } from '../../util/calculate-bundle-sha.js';
+import { calculateBundleSha } from '../../util/calculate-bundle-sha.js';
 import { spinnerify } from '../../util/spinner.js';
 import { uploadBundle } from '../../util/upload-bundle.js';
-export async function upload({ contents, versionId, bundleId, clientBundleUploadUrl, serverBundleUploadUrl, appId, settingsSchema, }) {
+export async function upload({ contents, appId, targetOrganizationId, environmentVariables, cliVersion, settingsSchema, }) {
     return await spinnerify('Uploading...', () => `Upload complete at ${new Date().toLocaleTimeString()}`, async () => {
         const [clientBundle, serverBundle] = contents;
-        const bundleSha = calculateBundleShas(clientBundle, serverBundle);
-        const uploadResults = await combineAsync([
-            uploadBundle(clientBundle, clientBundleUploadUrl),
-            uploadBundle(serverBundle, serverBundleUploadUrl),
-        ]);
-        if (isErrored(uploadResults)) {
-            return uploadResults;
+        const clientSha = calculateBundleSha(clientBundle);
+        const serverSha = calculateBundleSha(serverBundle);
+        const checkResult = await api.checkBundles({ appId, clientSha, serverSha });
+        if (isErrored(checkResult)) {
+            return checkResult;
+        }
+        const uploads = [];
+        if (!checkResult.value.client.exists) {
+            uploads.push(uploadBundle(clientBundle, checkResult.value.client.uploadUrl));
+        }
+        if (!checkResult.value.server.exists) {
+            uploads.push(uploadBundle(serverBundle, checkResult.value.server.uploadUrl));
+        }
+        if (uploads.length > 0) {
+            const uploadResults = await combineAsync(uploads);
+            if (isErrored(uploadResults)) {
+                return uploadResults;
+            }
+        }
+        const confirmResult = await api.confirmBundles({ appId, clientSha, serverSha });
+        if (isErrored(confirmResult)) {
+            return confirmResult;
         }
         if (settingsSchema) {
             process.stdout.write(`${chalk.green('✓ ')}Settings schema included\n`);
         }
-        const completeBundleUploadResult = await api.completeBundleUpload({
+        const deployResult = await api.createDeployment({
             appId,
-            versionId,
-            bundleId,
-            bundleSha,
+            clientBundleSha: clientSha,
+            serverBundleSha: serverSha,
+            deploymentType: 'development',
+            targetOrganizationId,
+            environmentVariables,
             settingsSchema,
+            metadata: { cliVersion },
         });
-        if (isErrored(completeBundleUploadResult)) {
-            return completeBundleUploadResult;
+        if (isErrored(deployResult)) {
+            return deployResult;
         }
         try {
             notifier.notify({

package/lib/commands/dev.js

@@ -103,7 +103,9 @@ export const dev = new Command('dev')
         }
     };
     try {
-        const { appId, appSlug, organization, devVersionId, bundleId, clientBundleUploadUrl, serverBundleUploadUrl, } = await boot({ organizationSlug });
+        const { appId, appSlug, organization, environmentVariables, cliVersion } = await boot({
+            organizationSlug,
+        });
         const cleanupOnboardingDaemon = onboarding({ appId, appSlug, organization });
         cleanupFunctions.push(cleanupOnboardingDaemon);
         let haveTsErrors = false;
@@ -126,15 +128,14 @@ export const dev = new Command('dev')
             }
             const uploadResult = await upload({
                 contents,
-                versionId: devVersionId,
-                bundleId,
-                clientBundleUploadUrl,
-                serverBundleUploadUrl,
                 appId,
+                targetOrganizationId: organization.id,
+                environmentVariables,
+                cliVersion,
                 settingsSchema,
             });
             if (isErrored(uploadResult)) {
-                printUploadError(uploadResult.error);
+                printUploadError(uploadResult);
             }
         }, async (error) => {
             haveBundlingErrors = true;

package/lib/commands/version/create.js

@@ -7,9 +7,8 @@ import { combineAsync, isErrored } from '../../errors.js';
 import { printCliVersionError, printFetcherError, printPackageJsonError, } from '../../print-errors.js';
 import { getAppInfo } from '../../spinners/get-app-info.spinner.js';
 import { getAppSlugFromPackageJson } from '../../spinners/get-app-slug-from-package-json.js';
-import { getVersions } from '../../spinners/get-versions.spinner.js';
 import { assertAppSettings } from '../../util/assert-app-settings.js';
-import { calculateBundleShas } from '../../util/calculate-bundle-sha.js';
+import { calculateBundleSha } from '../../util/calculate-bundle-sha.js';
 import { ensureAppEntryPoint } from '../../util/ensure-app-entry-point.js';
 import { exitWithMissingAppSettings } from '../../util/exit-with-missing-app-settings.js';
 import { exitWithMissingEntryPoint } from '../../util/exit-with-missing-entry-point.js';
@@ -20,7 +19,7 @@ import { uploadBundle } from '../../util/upload-bundle.js';
 import { printBuildContextError } from '../dev/prepare-build-context.js';
 import { bundleJavaScript } from './create/bundle-javascript.js';
 export const versionCreate = new Command('create')
-    .description('Create a new unpublished version of your auxx app')
+    .description('Create a new deployment of your auxx app')
     .action(async () => {
     if (USE_APP_TS) {
         const appEntryPointResult = await ensureAppEntryPoint();
@@ -70,56 +69,62 @@ export const versionCreate = new Command('create')
     if (settingsSchema) {
         process.stdout.write(`${chalk.green('✓ ')}Settings schema extracted\n`);
     }
-    const bundleSha = calculateBundleShas(clientBundle, serverBundle);
-    const versionsResult = await getVersions(appInfo);
-    if (isErrored(versionsResult)) {
-        printFetcherError('Error fetching versions', versionsResult.error);
-        process.exit(1);
-    }
-    const versions = versionsResult.value;
-    const versionResult = await spinnerify('Uploading...', 'Upload complete', async () => {
+    const deployResult = await spinnerify('Uploading...', 'Upload complete', async () => {
         const cliVersionResult = loadAuxxCliVersion();
         if (isErrored(cliVersionResult)) {
             printCliVersionError(cliVersionResult);
             process.exit(1);
         }
         const cliVersion = cliVersionResult.value;
-        const versionResult = await api.createVersion({
+        const clientSha = calculateBundleSha(clientBundle);
+        const serverSha = calculateBundleSha(serverBundle);
+        const checkResult = await api.checkBundles({ appId: appInfo.id, clientSha, serverSha });
+        if (isErrored(checkResult)) {
+            printFetcherError('Error checking bundles', checkResult);
+            process.exit(1);
+        }
+        const uploads = [];
+        if (!checkResult.value.client.exists) {
+            uploads.push(uploadBundle(clientBundle, checkResult.value.client.uploadUrl));
+        }
+        if (!checkResult.value.server.exists) {
+            uploads.push(uploadBundle(serverBundle, checkResult.value.server.uploadUrl));
+        }
+        if (uploads.length > 0) {
+            const uploadResult = await combineAsync(uploads);
+            if (isErrored(uploadResult)) {
+                process.stderr.write(`${chalk.red('✖ ')}Failed to upload bundle\n`);
+                process.exit(1);
+            }
+        }
+        const confirmResult = await api.confirmBundles({
             appId: appInfo.id,
-            major: versions.length === 0 ? 1 : Math.max(...versions.map((version) => version.major), 1),
-            cliVersion,
+            clientSha,
+            serverSha,
         });
-        if (isErrored(versionResult)) {
-            printFetcherError('Error creating version', versionResult);
+        if (isErrored(confirmResult)) {
+            printFetcherError('Error confirming bundles', confirmResult);
             process.exit(1);
         }
-        const { bundle } = versionResult.value;
-        const uploadResult = await combineAsync([
-            uploadBundle(clientBundle, bundle.clientBundleUploadUrl),
-            uploadBundle(serverBundle, bundle.serverBundleUploadUrl),
-        ]);
-        if (isErrored(uploadResult)) {
-            process.stderr.write(`${chalk.red('✖ ')}Failed to upload bundle to: ${uploadResult.error.uploadUrl}\n`);
+        const result = await api.createDeployment({
+            appId: appInfo.id,
+            clientBundleSha: clientSha,
+            serverBundleSha: serverSha,
+            deploymentType: 'production',
+            settingsSchema,
+            metadata: { cliVersion },
+        });
+        if (isErrored(result)) {
+            printFetcherError('Error creating deployment', result);
             process.exit(1);
         }
-        return versionResult;
+        return result;
     });
-    if (isErrored(versionResult)) {
-        process.stderr.write(`${chalk.red('✖ ')}Failed to create version: ${versionResult.error}\n`);
-        process.exit(1);
-    }
-    const version = versionResult.value;
-    const signingResult = await spinnerify('Signing bundles...', 'Bundles signed', async () => await api.completeProdBundleUpload({
-        appId: appInfo.id,
-        versionId: version.versionId,
-        bundleId: version.bundle.id,
-        bundleSha,
-        settingsSchema,
-    }));
-    if (isErrored(signingResult)) {
-        printFetcherError('Error signing bundles', signingResult.error);
+    if (isErrored(deployResult)) {
+        process.stderr.write(`${chalk.red('✖ ')}Failed to create deployment: ${deployResult.error}\n`);
         process.exit(1);
     }
-    process.stdout.write(`\nVersion ${chalk.green(`${version.major}.${version.minor}`)} created!\n\n`);
+    const deployment = deployResult.value;
+    process.stdout.write(`\nDeployment ${chalk.green(deployment.version ?? deployment.deploymentId)} created!\n\n`);
     process.exit(0);
 });

package/lib/commands/version/list.js

@@ -2,15 +2,16 @@ import chalk from 'chalk';
 import Table from 'cli-table3';
 import { Command } from 'commander';
 import { format as formatDate } from 'date-fns';
+import { api } from '../../api/api.js';
 import { authenticator } from '../../auth/auth.js';
 import { isErrored } from '../../errors.js';
 import { printFetcherError, printPackageJsonError } from '../../print-errors.js';
 import { getAppInfo } from '../../spinners/get-app-info.spinner.js';
 import { getAppSlugFromPackageJson } from '../../spinners/get-app-slug-from-package-json.js';
-import { getVersions } from '../../spinners/get-versions.spinner.js';
+import { spinnerify } from '../../util/spinner.js';
 export const versionList = new Command()
     .name('list')
-    .description('List all versions of your app')
+    .description('List all production deployments of your app')
     .action(async () => {
     await authenticator.ensureAuthed();
     const appSlugResult = await getAppSlugFromPackageJson();
@@ -25,42 +26,45 @@ export const versionList = new Command()
         process.exit(1);
     }
     const appInfo = appInfoResult.value;
-    const versionsResult = await getVersions(appInfo);
-    if (isErrored(versionsResult)) {
-        printFetcherError('Error loading versions', versionsResult.error);
+    const deploymentsResult = await spinnerify('Loading deployments...', 'Deployments loaded', async () => await api.listDeployments({ appId: appInfo.id, type: 'production' }));
+    if (isErrored(deploymentsResult)) {
+        printFetcherError('Error loading deployments', deploymentsResult.error);
         process.exit(1);
     }
-    const versions = versionsResult.value;
-    if (versions.length === 0) {
-        process.stdout.write('No versions found\n');
+    const deployments = deploymentsResult.value;
+    if (deployments.length === 0) {
+        process.stdout.write('No deployments found\n');
         process.exit(0);
     }
+    const statusColors = {
+        active: chalk.green,
+        'pending-review': chalk.yellow,
+        'in-review': chalk.yellow,
+        approved: chalk.cyan,
+        published: chalk.green,
+        rejected: chalk.red,
+        withdrawn: chalk.gray,
+        deprecated: chalk.gray,
+    };
     const table = new Table({
-        head: ['Version', 'Status', 'Published', 'Installations', 'Created'].map((h) => chalk.bold(h)),
+        head: ['Version', 'Status', 'Bundles', 'Created'].map((h) => chalk.bold(h)),
         style: {
             head: [],
             border: [],
         },
-        colAligns: ['center', 'left', 'center', 'right', 'left'],
+        colAligns: ['center', 'left', 'left', 'left'],
     });
-    versions.forEach((version) => {
-        const statusColors = {
-            private: chalk.gray,
-            'in-review': chalk.yellow,
-            published: chalk.green,
-            rejected: chalk.red,
-            unpublished: chalk.gray,
-        };
-        const formattedStatus = version.publication_status
-            .split('_')
+    deployments.forEach((d) => {
+        const formattedStatus = d.status
+            .split('-')
             .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
             .join(' ');
+        const colorFn = statusColors[d.status] ?? chalk.white;
         table.push([
-            `${version.major}.${version.minor}`,
-            statusColors[version.publication_status](formattedStatus),
-            version.is_published ? 'Yes' : 'No',
-            version.num_installations.toLocaleString(),
-            formatDate(new Date(version.created_at), 'MMM d, yyyy, HH:mm'),
+            d.version ?? d.id.slice(0, 8),
+            colorFn(formattedStatus),
+            d.clientBundleSha.slice(0, 8),
+            formatDate(new Date(d.createdAt), 'MMM d, yyyy, HH:mm'),
         ]);
     });
     process.stdout.write('\n' + table.toString() + '\n');

package/lib/print-errors.js

@@ -18,17 +18,25 @@ export function printFetcherError(message, { error }) {
             break;
     }
 }
-export function printUploadError(error) {
-    const e = error.error;
+export function printUploadError(result) {
+    const e = result.error;
     switch (e.code) {
         case 'BUNDLE_UPLOAD_ERROR':
             process.stderr.write(chalk.red(`Error uploading bundle: ${e.uploadUrl}\n`));
+            if (e.status) {
+                process.stderr.write(chalk.red(`  Status: ${e.status} ${e.statusText ?? ''}\n`));
+            }
             break;
         case 'START_UPLOAD_ERROR':
-            process.stderr.write(chalk.red(`Error starting upload: ${e}\n`));
+            process.stderr.write(chalk.red(`Error starting upload: ${e.error.message}\n`));
+            break;
+        case 'CHECK_BUNDLES_ERROR':
+        case 'CONFIRM_BUNDLES_ERROR':
+        case 'CREATE_DEPLOYMENT_ERROR':
+            printFetcherError(`Upload failed (${e.code})`, e);
             break;
-        case 'COMPLETE_BUNDLE_UPLOAD_ERROR':
-            process.stderr.write(chalk.red(`Error completing bundle upload: ${e}\n`));
+        default:
+            process.stderr.write(chalk.red(`Upload error: ${e.code}\n`));
             break;
     }
 }

package/lib/util/calculate-bundle-sha.js

@@ -2,7 +2,3 @@ import { createHash } from 'crypto';
 export function calculateBundleSha(bundleContent) {
     return createHash('sha256').update(bundleContent).digest('hex');
 }
-export function calculateBundleShas(clientBundle, serverBundle) {
-    const combined = `${clientBundle}\n---BUNDLE_SEPARATOR---\n${serverBundle}`;
-    return calculateBundleSha(combined);
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@auxx/sdk",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "description": "CLI tool and SDK for creating Auxx apps",
   "type": "module",
   "bin": {

package/lib/spinners/get-versions.spinner.js

@@ -1,5 +0,0 @@
-import { api } from '../api/api.js';
-import { spinnerify } from '../util/spinner.js';
-export async function getVersions(appInfo) {
-    return await spinnerify('Loading versions...', 'Versions loaded', async () => await api.fetchVersions(appInfo.id));
-}