@liquidmetal-ai/raindrop 0.0.0

package/dist/commands/auth/list.js

@@ -0,0 +1,55 @@
+import { Flags } from '@oclif/core';
+import { BaseCommand } from '../../base-command.js';
+import { readState } from '../../index.js';
+export default class List extends BaseCommand {
+    static args = {};
+    static description = 'List authentications';
+    static flags = {
+        output: Flags.string({
+            char: 'o',
+            description: 'output format',
+            default: 'table',
+            options: ['text', 'table', 'json'],
+        }),
+    };
+    async run() {
+        const state = await readState(this.config.configDir);
+        switch (this.flags.output) {
+            case 'text':
+                for (const [orgId, token] of Object.entries(state.organizationIdToBearerToken)) {
+                    const isSelected = token.organizationId === state.currentOrganizationId;
+                    console.log(`${orgId}${isSelected ? ' (current)' : ''} - ${token.userEmail} ${token.organizationName}`);
+                }
+                break;
+            case 'json':
+                console.log(JSON.stringify(Object.entries(state.organizationIdToBearerToken).map(([_, token]) => {
+                    const isSelected = token.organizationId === state.currentOrganizationId;
+                    return {
+                        organizationId: token.organizationId,
+                        organizationName: token.organizationName,
+                        userEmail: token.userEmail,
+                        isSelected,
+                    };
+                })));
+                break;
+            case 'table':
+                console.table(Object.entries(state.organizationIdToBearerToken)
+                    .map(([_, token]) => {
+                    const isSelected = token.organizationId === state.currentOrganizationId;
+                    return {
+                        organizationId: token.organizationId,
+                        organizationName: token.organizationName,
+                        userEmail: token.userEmail,
+                        isSelected,
+                    };
+                })
+                    .reduce((memo, row) => {
+                    memo[row.organizationId] = row;
+                    return memo;
+                }, 
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                {}), ['organizationName', 'userEmail', 'isSelected']);
+                break;
+        }
+    }
+}

package/dist/commands/auth/login.d.ts

@@ -0,0 +1,10 @@
+import { BaseCommand } from '../../base-command.js';
+export default class Login extends BaseCommand<typeof Login> {
+    static args: {};
+    static description: string;
+    static flags: {
+        rainbowAuthService: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}
+//# sourceMappingURL=login.d.ts.map

package/dist/commands/auth/login.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"login.d.ts","sourceRoot":"","sources":["../../../src/commands/auth/login.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAQpD,MAAM,CAAC,OAAO,OAAO,KAAM,SAAQ,WAAW,CAAC,OAAO,KAAK,CAAC;IAC1D,MAAM,CAAC,IAAI,KAAM;IAEjB,MAAM,CAAC,WAAW,SAAuF;IAEzG,MAAM,CAAC,KAAK;;MAMV;IAEI,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;CA8D3B"}

package/dist/commands/auth/login.js

@@ -0,0 +1,69 @@
+import { RainbowAuthService } from '@liquidmetal-ai/drizzle/liquidmetal/v1alpha1/rainbow_auth_connect';
+import { Flags } from '@oclif/core';
+import open from 'open';
+import qrcode from 'qrcode-terminal';
+import { spinner } from 'zx';
+import { BaseCommand } from '../../base-command.js';
+import { readState, replaceState, useClient } from '../../index.js';
+function sleep(dur) {
+    const ms = dur.nanos / 1e6 + Number(dur.seconds * 1000n);
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export default class Login extends BaseCommand {
+    static args = {};
+    static description = 'Logs a user into the LiquidMetal platform. Supports browser-based authentication.';
+    static flags = {
+        rainbowAuthService: Flags.string({
+            default: 'https://liquidmetal.run/api/connect',
+            hidden: true,
+            env: 'LIQUIDMETAL_RAINBOW_AUTH_SERVICE',
+        }),
+    };
+    async run() {
+        const rainbowAuth = useClient(RainbowAuthService, this.flags.rainbowAuthService);
+        const clientId = `raindrop@${this.config.version}`;
+        const { deviceCode, verificationUriComplete, expiresAt, interval: initialInterval, } = await rainbowAuth.deviceAuthorization({
+            clientId,
+        });
+        if (!expiresAt || !initialInterval) {
+            throw new Error(`expected expiresAt and interval to be set`);
+        }
+        qrcode.generate(verificationUriComplete, { small: true });
+        console.log(`Scan the QR code or, using a browser visit: ${verificationUriComplete}`);
+        console.log('\n\nopening url...');
+        open(verificationUriComplete);
+        await spinner('Waiting for session...', async () => {
+            let interval = initialInterval;
+            let done = false;
+            while (!done) {
+                if (new Date() > expiresAt.toDate()) {
+                    console.error('failed to authenticate in time');
+                    this.exit(1);
+                }
+                await sleep(interval);
+                const { response } = await rainbowAuth.deviceAccessToken({
+                    deviceCode,
+                });
+                switch (response.case) {
+                    case 'authorizationPending':
+                        if (response.value.interval) {
+                            interval = response.value.interval;
+                        }
+                        break;
+                    case 'bearerToken':
+                        {
+                            const state = await readState(this.config.configDir);
+                            state.currentOrganizationId = response.value.organizationId;
+                            state.organizationIdToBearerToken[response.value.organizationId] = response.value;
+                            await replaceState(this.config.configDir, state);
+                            console.log(`Logged in as ${response.value.userEmail} to ${response.value.organizationName}`);
+                        }
+                        done = true;
+                        break;
+                    default:
+                        console.error(`unhandled device access token response case=${response.case}`);
+                }
+            }
+        });
+    }
+}

package/dist/commands/auth/logout.d.ts

@@ -0,0 +1,8 @@
+import { BaseCommand } from '../../base-command.js';
+export default class Logout extends BaseCommand<typeof Logout> {
+    static args: {};
+    static description: string;
+    static flags: {};
+    run(): Promise<void>;
+}
+//# sourceMappingURL=logout.d.ts.map

package/dist/commands/auth/logout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logout.d.ts","sourceRoot":"","sources":["../../../src/commands/auth/logout.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAGpD,MAAM,CAAC,OAAO,OAAO,MAAO,SAAQ,WAAW,CAAC,OAAO,MAAM,CAAC;IAC5D,MAAM,CAAC,IAAI,KAAM;IAEjB,MAAM,CAAC,WAAW,SAA4B;IAE9C,MAAM,CAAC,KAAK,KAAM;IAEZ,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;CAU3B"}

package/dist/commands/auth/logout.js

@@ -0,0 +1,15 @@
+import { BaseCommand } from '../../base-command.js';
+import { readState, replaceState } from '../../index.js';
+export default class Logout extends BaseCommand {
+    static args = {};
+    static description = 'Logout authentications';
+    static flags = {};
+    async run() {
+        const state = await readState(this.config.configDir);
+        if (state.currentOrganizationId) {
+            delete state.organizationIdToBearerToken[state.currentOrganizationId];
+            state.currentOrganizationId = undefined;
+        }
+        await replaceState(this.config.configDir, state);
+    }
+}

package/dist/commands/auth/select.d.ts

@@ -0,0 +1,10 @@
+import { BaseCommand } from '../../base-command.js';
+export default class Select extends BaseCommand<typeof Select> {
+    static args: {};
+    static description: string;
+    static flags: {
+        organizationId: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}
+//# sourceMappingURL=select.d.ts.map

package/dist/commands/auth/select.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"select.d.ts","sourceRoot":"","sources":["../../../src/commands/auth/select.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAGpD,MAAM,CAAC,OAAO,OAAO,MAAO,SAAQ,WAAW,CAAC,OAAO,MAAM,CAAC;IAC5D,MAAM,CAAC,IAAI,KAAM;IAEjB,MAAM,CAAC,WAAW,SAAgC;IAElD,MAAM,CAAC,KAAK;;MAIV;IAEI,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;CA+B3B"}

package/dist/commands/auth/select.js

@@ -0,0 +1,39 @@
+import { select } from '@inquirer/prompts';
+import { Flags } from '@oclif/core';
+import { BaseCommand } from '../../base-command.js';
+import { readState, replaceState } from '../../index.js';
+export default class Select extends BaseCommand {
+    static args = {};
+    static description = 'Select active organization';
+    static flags = {
+        organizationId: Flags.string({
+            description: 'organizationId to select as active',
+        }),
+    };
+    async run() {
+        const state = await readState(this.config.configDir);
+        let organizationId = this.flags.organizationId;
+        if (!organizationId) {
+            if (Object.entries(state.organizationIdToBearerToken).length === 0) {
+                this.error(`no organizations are authorized. see raindrop auth login.`);
+            }
+            organizationId = await select({
+                message: 'Select an organization',
+                default: state.currentOrganizationId,
+                choices: Object.entries(state.organizationIdToBearerToken)
+                    .map(([_, token]) => {
+                    return {
+                        name: `${token.userEmail} - ${token.organizationName}`,
+                        value: token.organizationId,
+                    };
+                })
+                    .sort((a, b) => a.name.localeCompare(b.name)),
+            });
+        }
+        if (!state.organizationIdToBearerToken[organizationId]) {
+            this.error(`${organizationId} not authenticated`);
+        }
+        state.currentOrganizationId = organizationId;
+        await replaceState(this.config.configDir, state);
+    }
+}

package/dist/commands/build/branch.d.ts

@@ -0,0 +1,16 @@
+import { BaseCommand } from '../../base-command.js';
+export default class Branch extends BaseCommand<typeof Branch> {
+    static args: {};
+    static description: string;
+    static examples: string[];
+    static flags: {
+        previousVersionId: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        select: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        impersonate: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        rainbowAuthService: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        config: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        manifest: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}
+//# sourceMappingURL=branch.d.ts.map

package/dist/commands/build/branch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"branch.d.ts","sourceRoot":"","sources":["../../../src/commands/build/branch.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACpD,MAAM,CAAC,OAAO,OAAO,MAAO,SAAQ,WAAW,CAAC,OAAO,MAAM,CAAC;IAC5D,MAAM,CAAC,IAAI,KAAM;IAEjB,MAAM,CAAC,WAAW,SAAiD;IAEnE,MAAM,CAAC,QAAQ,WAGb;IAEF,MAAM,CAAC,KAAK;;;;;;;MA8BV;IAEI,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;CA2C3B"}

package/dist/commands/build/branch.js

@@ -0,0 +1,81 @@
+import { valueOf } from '@liquidmetal-ai/drizzle/appify/build';
+import { Flags } from '@oclif/core';
+import { BaseCommand } from '../../base-command.js';
+export default class Branch extends BaseCommand {
+    static args = {};
+    static description = 'create a new branch in the Raindrop catalog';
+    static examples = [
+        `<%= config.bin %> <%= command.id %> .
+Create a new branch in the Raindrop catalog.`,
+    ];
+    static flags = {
+        previousVersionId: Flags.string({
+            char: 'p',
+            aliases: ['prev'],
+            description: 'previous version ID',
+            required: false,
+            exclusive: ['select'],
+        }),
+        select: Flags.string({
+            char: 's',
+            description: 'select a specific version ID',
+            required: false,
+            exclusive: ['previousVersionId'],
+        }),
+        impersonate: Flags.string({
+            char: 'i',
+            description: 'impersonate organization',
+            required: false,
+            hidden: true,
+        }),
+        rainbowAuthService: Flags.string({
+            default: 'https://liquidmetal.run/api/connect',
+            hidden: true,
+            env: 'LIQUIDMETAL_RAINBOW_AUTH_SERVICE',
+        }),
+        config: Flags.string({
+            default: '.raindrop/config.json',
+            hidden: true,
+        }),
+        manifest: Flags.string({ default: 'raindrop.manifest', description: 'project manifest' }),
+    };
+    async run() {
+        const { client: catalogService, userId, organizationId: defaultOrganizationId } = await this.catalogService();
+        const organizationId = this.flags.impersonate ?? defaultOrganizationId;
+        const config = await this.loadConfig();
+        // If we're selecting a version, just update config.
+        if (this.flags.select) {
+            // Check if this is a valid version.
+            const resp = await catalogService.versions({ userId, organizationId });
+            const validVersion = resp.versions.some((app) => {
+                if (app.versionId === this.flags.select) {
+                    return true;
+                }
+            });
+            if (!validVersion) {
+                this.error(`Version ${this.flags.select} does not exist`, { exit: 1 });
+            }
+            // We have a valid version, check to see if it exists against
+            // this application or none.
+            const apps = await this.loadManifest();
+            const app = apps[0];
+            if (app === undefined) {
+                this.error('No application found in manifest', { exit: 1 });
+            }
+            const applicationResp = await catalogService.applications({ userId, organizationId });
+            if (applicationResp.applications.some((a) => (a.name !== valueOf(app.name) && a.versionId === this.flags.select))) {
+                this.error(`Cannot select version ${this.flags.select} belonging to another application`, { exit: 1 });
+            }
+            config.versionId = this.flags.select;
+            await this.saveConfig(config);
+            return;
+        }
+        const resp = await catalogService.createVersion({
+            userId,
+            organizationId,
+            previousVersionId: this.flags.previousVersionId || config.versionId,
+        });
+        config.versionId = resp.versionId;
+        await this.saveConfig(config);
+    }
+}

package/dist/commands/build/delete.d.ts

@@ -0,0 +1,19 @@
+import { BaseCommand } from '../../base-command.js';
+export default class Delete extends BaseCommand<typeof Delete> {
+    static args: {
+        application: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        output: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        version: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        all: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        impersonate: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        rainbowAuthService: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        manifest: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        config: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}
+//# sourceMappingURL=delete.d.ts.map

package/dist/commands/build/delete.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delete.d.ts","sourceRoot":"","sources":["../../../src/commands/build/delete.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAGpD,MAAM,CAAC,OAAO,OAAO,MAAO,SAAQ,WAAW,CAAC,OAAO,MAAM,CAAC;IAC5D,MAAM,CAAC,IAAI;;MAET;IAEF,MAAM,CAAC,WAAW,SAAkC;IAEpD,MAAM,CAAC,QAAQ,WAIb;IAEF,MAAM,CAAC,KAAK;;;;;;;;MAgCV;IAEI,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;CAqD3B"}

package/dist/commands/build/delete.js

@@ -0,0 +1,99 @@
+import { valueOf } from '@liquidmetal-ai/drizzle/appify/build';
+import { Args, Flags } from '@oclif/core';
+import { BaseCommand } from '../../base-command.js';
+import { defaultConfig } from '../../config.js';
+export default class Delete extends BaseCommand {
+    static args = {
+        application: Args.string({ char: 'a', description: 'application name', required: false }),
+    };
+    static description = 'delete Raindrop applications';
+    static examples = [
+        `<%= config.bin %> <%= command.id %> .
+Deleted (application) at version (version)
+`,
+    ];
+    static flags = {
+        output: Flags.string({
+            char: 'o',
+            description: 'output format',
+            default: 'table',
+            options: ['text', 'table', 'json'],
+        }),
+        version: Flags.string({
+            char: 'v',
+            description: 'application version to delete',
+            required: false,
+            exclusive: ['all'],
+        }),
+        all: Flags.boolean({
+            char: 'a',
+            description: 'delete all application versions',
+            required: false,
+            exclusive: ['version'],
+        }),
+        impersonate: Flags.string({
+            char: 'i',
+            description: 'impersonate organization',
+            required: false,
+            hidden: true,
+        }),
+        rainbowAuthService: Flags.string({
+            default: 'https://liquidmetal.run/api/connect',
+            hidden: true,
+            env: 'LIQUIDMETAL_RAINBOW_AUTH_SERVICE',
+        }),
+        manifest: Flags.string({ default: 'raindrop.manifest', description: 'project manifest' }),
+        config: Flags.string({ default: '.raindrop/config.json', hidden: true }),
+    };
+    async run() {
+        const { client: catalogService, userId, organizationId } = await this.catalogService();
+        // Get the version ID to delete, or undefined if all versions
+        // should be deleted. Flags.all and Flags.versionId are exclusive,
+        // and the default versionId is the one in the config.
+        let versionId = this.flags.version;
+        if (this.flags.all) {
+            versionId = undefined;
+        }
+        else if (this.flags.version === undefined) {
+            const config = await this.loadConfig();
+            versionId = config.versionId;
+        }
+        // Don't allow deleting the epoch version.
+        if (versionId === defaultConfig.versionId) {
+            this.error('There are no applications at the epoch version', { exit: 1 });
+        }
+        if (this.args.application === undefined) {
+            const apps = await this.loadManifest();
+            const app = apps[0];
+            if (app === undefined) {
+                this.error('No application found in manifest and no application name specified', { exit: 1 });
+            }
+            this.args.application = valueOf(app.name);
+        }
+        try {
+            const resp = await catalogService.deleteApplications({
+                userId,
+                organizationId: this.flags.impersonate ?? organizationId,
+                // Omitting versionId will delete all versions of the application
+                applications: [{ name: this.args.application, versionId }],
+            });
+            if (resp.failure.length) {
+                this.error(`Failed to delete applications: ${resp.failure.map((f) => `${f.name}@${f.versionId}`).join(', ')}`, {
+                    exit: 1,
+                });
+            }
+        }
+        catch (e) {
+            if (e instanceof Error) {
+                this.error(`Failed to delete application ${this.args.application}: ${e.message}`, { exit: 1 });
+            }
+            throw e;
+        }
+        if (this.flags.all) {
+            this.log(`Deleted all versions of ${this.args.application}`);
+        }
+        else {
+            this.log(`Deleted ${this.args.application} at version ${versionId}`);
+        }
+    }
+}

package/dist/commands/build/deploy.d.ts

@@ -0,0 +1,18 @@
+import { BaseCommand } from '../../base-command.js';
+export default class Deploy extends BaseCommand<typeof Deploy> {
+    static args: {};
+    static description: string;
+    static examples: string[];
+    static flags: {
+        root: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        manifest: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        output: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        versionId: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        impersonate: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        rainbowAuthService: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        start: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        config: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}
+//# sourceMappingURL=deploy.d.ts.map

package/dist/commands/build/deploy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deploy.d.ts","sourceRoot":"","sources":["../../../src/commands/build/deploy.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAIpD,MAAM,CAAC,OAAO,OAAO,MAAO,SAAQ,WAAW,CAAC,OAAO,MAAM,CAAC;IAC5D,MAAM,CAAC,IAAI,KAAM;IAEjB,MAAM,CAAC,WAAW,SAAmC;IAErD,MAAM,CAAC,QAAQ,WAIb;IAEF,MAAM,CAAC,KAAK;;;;;;;;;MAiCV;IAEI,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;CAkG3B"}

package/dist/commands/build/deploy.js

@@ -0,0 +1,144 @@
+import { valueOf } from '@liquidmetal-ai/drizzle/appify/build';
+import { JSONTranslator, Parser, Tokenizer } from '@liquidmetal-ai/drizzle/appify/parse';
+import { archive } from '@liquidmetal-ai/drizzle/codestore';
+import { BundleArchiveType } from '@liquidmetal-ai/drizzle/liquidmetal/v1alpha1/catalog_pb';
+import { FileSystemBundle } from '@liquidmetal-ai/drizzle/unsafe/codestore';
+import { Flags } from '@oclif/core';
+import fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { BaseCommand } from '../../base-command.js';
+import { buildHandlers } from '../../build.js';
+import { defaultConfig } from '../../config.js';
+export default class Deploy extends BaseCommand {
+    static args = {};
+    static description = 'deploy a Raindrop application';
+    static examples = [
+        `<%= config.bin %> <%= command.id %> .
+Deploy a Raindrop application.
+`,
+    ];
+    static flags = {
+        root: Flags.string({ char: 'r', description: 'root directory', required: false, default: process.cwd() }),
+        manifest: Flags.string({
+            char: 'm',
+            description: 'project manifest',
+            required: false,
+            default: 'raindrop.manifest',
+        }),
+        output: Flags.string({ char: 'o', description: 'output directory', required: false, default: 'dist' }),
+        versionId: Flags.string({
+            char: 'v',
+            aliases: ['version'],
+            description: 'version ID',
+            required: false,
+        }),
+        impersonate: Flags.string({
+            char: 'i',
+            description: 'impersonate organization',
+            required: false,
+            hidden: true,
+        }),
+        rainbowAuthService: Flags.string({
+            default: 'https://liquidmetal.run/api/connect',
+            hidden: true,
+            env: 'LIQUIDMETAL_RAINBOW_AUTH_SERVICE',
+        }),
+        start: Flags.boolean({
+            char: 's',
+            description: 'start the application after deploying',
+            required: false,
+            default: false,
+        }),
+        config: Flags.string({ default: '.raindrop/config.json', hidden: true }),
+    };
+    async run() {
+        // Build then deploy
+        const manifestPath = path.isAbsolute(this.flags.manifest)
+            ? this.flags.manifest
+            : path.join(this.flags.root, this.flags.manifest);
+        // Do this first to check for errors.
+        const apps = await this.loadManifest();
+        const manifestContents = await fs.readFile(manifestPath, 'utf8');
+        // Now do a translate to get the JSON version of the manifest.
+        const tokenizer = new Tokenizer(await fs.readFile(manifestPath, 'utf8'));
+        const parser = new Parser(tokenizer);
+        const manifestJson = new JSONTranslator().translate(parser.parse());
+        const buildDir = path.isAbsolute(this.flags.output)
+            ? this.flags.output
+            : path.join(this.flags.root, this.flags.output);
+        await buildHandlers(this, apps, buildDir, this.flags.root);
+        const config = await this.loadConfig();
+        const versionId = this.flags.versionId || config.versionId;
+        if (versionId === defaultConfig.versionId) {
+            this.error('You must create a new version with `raindrop build branch` before deploying your first application', {
+                exit: 1,
+            });
+        }
+        const { client: catalogService, userId, organizationId: defaultOrganizationId } = await this.catalogService();
+        const organizationId = this.flags.impersonate ?? defaultOrganizationId;
+        const applications = apps.map((app) => ({
+            name: valueOf(app.name),
+            manifest: manifestContents,
+            manifestJson: JSON.stringify(manifestJson),
+            version: {
+                case: 'versionId',
+                value: versionId,
+            },
+            isActive: this.flags.start,
+        }));
+        const appsResp = await catalogService.createApplications({
+            applications,
+            userId,
+            organizationId,
+            suite: undefined, // TODO [bosgood] Provide suite name once available
+        });
+        // Upload bundle to this version's store.
+        for (const [i, app] of apps.entries()) {
+            const appResp = appsResp.applications[i];
+            if (!appResp) {
+                // TODO [bosgood] We'll be able to basically eliminate the possibility of this happening
+                // by converting createApplications in the API and State to a createMany function.
+                this.error(`Failed to create application ${valueOf(app.name)}, not uploading code bundle`, { exit: false });
+                continue;
+            }
+            const versionId = appResp.versionId;
+            this.log(`Created application "${valueOf(app.name)}" with version ID "${versionId}"`);
+            for (const handler of app.handlers()) {
+                const bundle = new FileSystemBundle(path.join(buildDir, valueOf(handler.name)));
+                await catalogService.uploadBundle({
+                    organizationId,
+                    applicationName: valueOf(app.name),
+                    applicationVersionId: versionId,
+                    archiveType: BundleArchiveType.ZIP,
+                    bundleName: valueOf(handler.name),
+                    archive: Buffer.from(await archive(bundle)),
+                });
+                this.log(`Uploaded bundle "${handler}"`);
+            }
+            // Per above, each application gets the same db bundle, which is
+            // boneheaded. src/db is pretty arbitrary.
+            const srcDir = path.join(this.flags.root, 'src');
+            const dbDir = path.join(srcDir, 'db');
+            let dbExists = false;
+            try {
+                const stat = await fs.lstat(dbDir);
+                dbExists = stat.isDirectory();
+            }
+            catch (_e) {
+                // Nothing to do
+            }
+            if (dbExists) {
+                const dbBundle = new FileSystemBundle(path.join(srcDir, 'db'));
+                await catalogService.uploadBundle({
+                    organizationId,
+                    applicationName: valueOf(app.name),
+                    applicationVersionId: versionId,
+                    archiveType: BundleArchiveType.ZIP,
+                    bundleName: 'db',
+                    archive: Buffer.from(await archive(dbBundle)),
+                });
+                this.log(`Uploaded bundle "db"`);
+            }
+        }
+    }
+}

package/dist/commands/build/env/get.d.ts

@@ -0,0 +1,19 @@
+import { BaseCommand } from '../../../base-command.js';
+export default class Get extends BaseCommand<typeof Get> {
+    static args: {
+        var: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        output: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        rainbowAuthService: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        manifest: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        versionId: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        application: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        impersonate: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        config: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}
+//# sourceMappingURL=get.d.ts.map

package/dist/commands/build/env/get.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get.d.ts","sourceRoot":"","sources":["../../../../src/commands/build/env/get.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAEvD,MAAM,CAAC,OAAO,OAAO,GAAI,SAAQ,WAAW,CAAC,OAAO,GAAG,CAAC;IACtD,MAAM,CAAC,IAAI;;MAET;IAEF,MAAM,CAAC,WAAW,SAA2B;IAE7C,MAAM,CAAC,QAAQ,WAIb;IAEF,MAAM,CAAC,KAAK;;;;;;;;MA+BV;IAEI,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;CAwD3B"}