@liquidmetal-ai/raindrop 0.0.0

package/dist/commands/build/start.js

@@ -0,0 +1,71 @@
+import { valueOf } from '@liquidmetal-ai/drizzle/appify/build';
+import { Flags } from '@oclif/core';
+import { BaseCommand } from '../../base-command.js';
+export default class Start extends BaseCommand {
+    static args = {};
+    static description = 'start a Raindrop application';
+    static examples = [
+        `<%= config.bin %> <%= command.id %> .
+Start a Raindrop application.
+`,
+    ];
+    static flags = {
+        config: Flags.string({ char: 'c', description: 'config file', required: false, default: '.raindrop/config.json' }),
+        manifest: Flags.string({
+            char: 'm',
+            description: 'project manifest',
+            required: false,
+            default: 'raindrop.manifest',
+        }),
+        application: Flags.string({
+            char: 'a',
+            description: 'application to start',
+            required: false,
+        }),
+        version: Flags.string({
+            char: 'v',
+            description: 'application version to start',
+            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',
+        }),
+    };
+    async run() {
+        const { client: catalogService, userId, organizationId } = await this.catalogService();
+        const config = await this.loadConfig();
+        let appName = this.flags.application;
+        if (appName === undefined) {
+            const apps = await this.loadManifest();
+            const app = apps[0];
+            if (app === undefined) {
+                this.error('No application found in manifest', { exit: 1 });
+            }
+            appName = valueOf(app.name);
+        }
+        const resp = await catalogService.setApplicationActiveStates({
+            states: [
+                {
+                    applicationName: this.flags.application || appName,
+                    applicationVersionId: this.flags.version || config.versionId,
+                    isActive: true,
+                },
+            ],
+            userId,
+            organizationId: this.flags.impersonate ?? organizationId,
+        });
+        if (resp.failure.length) {
+            this.error(`Failed to start applications: ${resp.failure.map((f) => `${f.name}@${f.versionId}`).join(', ')}`, {
+                exit: 1,
+            });
+        }
+    }
+}

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

@@ -0,0 +1,15 @@
+import { BaseCommand } from '../../base-command.js';
+export default class Stop extends BaseCommand<typeof Stop> {
+    static args: {};
+    static description: string;
+    static examples: string[];
+    static flags: {
+        application: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        version: 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>;
+    };
+    run(): Promise<void>;
+}
+//# sourceMappingURL=stop.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"stop.d.ts","sourceRoot":"","sources":["../../../src/commands/build/stop.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEpD,MAAM,CAAC,OAAO,OAAO,IAAK,SAAQ,WAAW,CAAC,OAAO,IAAI,CAAC;IACxD,MAAM,CAAC,IAAI,KAAM;IAEjB,MAAM,CAAC,WAAW,SAAiC;IAEnD,MAAM,CAAC,QAAQ,WAIb;IAEF,MAAM,CAAC,KAAK;;;;;;MAuBV;IAEI,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;CAiC3B"}

package/dist/commands/build/stop.js

@@ -0,0 +1,67 @@
+import { valueOf } from '@liquidmetal-ai/drizzle/appify/build';
+import { Flags } from '@oclif/core';
+import { BaseCommand } from '../../base-command.js';
+export default class Stop extends BaseCommand {
+    static args = {};
+    static description = 'stop a Raindrop application';
+    static examples = [
+        `<%= config.bin %> <%= command.id %> .
+Stop a Raindrop application.
+`,
+    ];
+    static flags = {
+        application: Flags.string({
+            char: 'a',
+            description: 'application to stop',
+            required: false,
+        }),
+        version: Flags.string({
+            char: 'v',
+            description: 'application version to start',
+            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',
+        }),
+        config: Flags.string({ default: '.raindrop/config.json', hidden: true }),
+    };
+    async run() {
+        const { client: catalogService, userId, organizationId } = await this.catalogService();
+        if (!this.flags.version) {
+            const config = await this.loadConfig();
+            this.flags.version = config.versionId;
+        }
+        if (!this.flags.application) {
+            const apps = await this.loadManifest();
+            const app = apps[0];
+            if (app === undefined) {
+                this.error('No application found in manifest', { exit: 1 });
+            }
+            this.flags.application = valueOf(app.name);
+        }
+        const resp = await catalogService.setApplicationActiveStates({
+            states: [
+                {
+                    applicationName: this.flags.application,
+                    applicationVersionId: this.flags.version,
+                    isActive: false,
+                },
+            ],
+            userId,
+            organizationId: this.flags.impersonate ?? organizationId,
+        });
+        if (resp.failure.length) {
+            this.error(`Failed to stop applications: ${resp.failure.map((f) => `${f.name}@${f.versionId}`).join(', ')}`, {
+                exit: 1,
+            });
+        }
+    }
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"token.d.ts","sourceRoot":"","sources":["../../../src/commands/build/token.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEpD,MAAM,CAAC,OAAO,OAAO,KAAM,SAAQ,WAAW,CAAC,OAAO,KAAK,CAAC;IAC1D,MAAM,CAAC,IAAI,KAAM;IAEjB,MAAM,CAAC,WAAW,SAAsD;IAExE,MAAM,CAAC,QAAQ,UAAM;IAErB,MAAM,CAAC,KAAK,KAAM;IAEZ,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;CAqC3B"}

package/dist/commands/build/token.js

@@ -0,0 +1,42 @@
+import open from 'open';
+import { BaseCommand } from '../../base-command.js';
+export default class Token extends BaseCommand {
+    static args = {};
+    static description = 'generate a link to create a Cloudflare API token';
+    static examples = [];
+    static flags = {};
+    async run() {
+        const raindropPermissions = [
+            { key: 'account_settings', type: 'read' },
+            { key: 'd1', type: 'edit' },
+            { key: 'memberships', type: 'read' },
+            { key: 'page', type: 'edit' },
+            { key: 'queues', type: 'edit' },
+            { key: 'user_details', type: 'read' },
+            { key: 'vectorize', type: 'edit' },
+            { key: 'workers_kv_storage', type: 'edit' },
+            { key: 'workers_r2', type: 'edit' },
+            { key: 'workers_routes', type: 'edit' },
+            { key: 'workers_scripts', type: 'edit' },
+            { key: 'workers_tail', type: 'read' },
+            { key: 'zone', type: 'read' },
+        ];
+        const tokenUrl = `https://dash.cloudflare.com/profile/api-tokens?permissionGroupKeys=${encodeURIComponent(JSON.stringify(raindropPermissions))}&name=Raindrop%20CLI%20Token`;
+        this.log(`You need to generate a token to use this tool.`);
+        this.log(`The token should have the following permissions:`);
+        for (const claim of raindropPermissions) {
+            this.log(`- ${claim.type} ${claim.key}`);
+        }
+        this.log(``);
+        this.log(`After generating the token, you must add it to your environment along
+with the account ID. The Account ID can be found in the Cloudflare
+dashboard by navigating to a domain under your account and looking on
+the lower right of the page.`);
+        this.log(``);
+        this.log(`export CLOUDFLARE_API_TOKEN=your_token`);
+        this.log(`export CLOUDFLARE_ACCOUNT_ID=your_account_id`);
+        this.log(``);
+        this.log(`Opening... ${tokenUrl}`);
+        await open(tokenUrl);
+    }
+}

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

@@ -0,0 +1,17 @@
+import { BaseCommand } from '../../base-command.js';
+export default class Upload extends BaseCommand<typeof Upload> {
+    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>;
+        config: 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, 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>;
+    };
+    run(): Promise<void>;
+}
+//# sourceMappingURL=upload.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"upload.d.ts","sourceRoot":"","sources":["../../../src/commands/build/upload.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAGpD,MAAM,CAAC,OAAO,OAAO,MAAO,SAAQ,WAAW,CAAC,OAAO,MAAM,CAAC;IAC5D,OAAgB,IAAI,KAAM;IAE1B,OAAgB,WAAW,SAAiD;IAE5E,OAAgB,QAAQ,WAA2C;IAEnE,OAAgB,KAAK;;;;;;;;MAsBnB;IAEW,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;CAyClC"}

package/dist/commands/build/upload.js

@@ -0,0 +1,75 @@
+import { valueOf } from '@liquidmetal-ai/drizzle/appify/build';
+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 path from 'node:path';
+import { BaseCommand } from '../../base-command.js';
+import { buildHandlers } from '../../build.js';
+export default class Upload extends BaseCommand {
+    static args = {};
+    static description = 'build and validate a LiquidMetal.AI project';
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    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',
+        }),
+        config: Flags.string({ char: 'c', description: 'config file', required: false, default: '.raindrop/config.json' }),
+        output: Flags.string({ char: 'o', description: 'output directory', required: false, default: 'dist' }),
+        versionId: Flags.string({ char: 'v', description: 'version ID', required: true }),
+        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',
+        }),
+    };
+    async run() {
+        const apps = await this.loadManifest();
+        const srcDir = path.join(this.flags.root, 'src');
+        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 { client: catalogService, organizationId: defaultOrganizationId, userId } = await this.catalogService();
+        const organizationId = this.flags.impersonate ?? defaultOrganizationId;
+        const config = await this.loadConfig();
+        const app = apps[0];
+        if (!app) {
+            this.error('No application found in manifest', { exit: 1 });
+        }
+        for (const handler of app.handlers()) {
+            const bundle = new FileSystemBundle(path.join(buildDir, valueOf(handler.name)));
+            await catalogService.uploadBundle({
+                userId,
+                organizationId,
+                applicationName: valueOf(app.name),
+                applicationVersionId: this.flags.versionId || config.versionId,
+                archiveType: BundleArchiveType.ZIP,
+                bundleName: valueOf(handler.name),
+                archive: Buffer.from(await archive(bundle)),
+            });
+        }
+        // Per above, each application gets the same db bundle, which is
+        // boneheaded. src/db is also pretty arbitrary.
+        const dbBundle = new FileSystemBundle(path.join(srcDir, 'db'));
+        await catalogService.uploadBundle({
+            userId,
+            organizationId,
+            applicationName: valueOf(app.name),
+            applicationVersionId: this.flags.versionId || config.versionId,
+            archiveType: BundleArchiveType.ZIP,
+            bundleName: 'db',
+            archive: Buffer.from(await archive(dbBundle)),
+        });
+    }
+}

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

@@ -0,0 +1,13 @@
+import { BaseCommand } from '../../base-command.js';
+export default class Build extends BaseCommand<typeof Build> {
+    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>;
+    };
+    run(): Promise<void>;
+}
+//# sourceMappingURL=validate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../../src/commands/build/validate.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAGpD,MAAM,CAAC,OAAO,OAAO,KAAM,SAAQ,WAAW,CAAC,OAAO,KAAK,CAAC;IAC1D,OAAgB,IAAI,KAAM;IAE1B,OAAgB,WAAW,SAAiD;IAE5E,OAAgB,QAAQ,WAA2C;IAEnE,OAAgB,KAAK;;;;MASnB;IAEW,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;CAQlC"}

package/dist/commands/build/validate.js

@@ -0,0 +1,26 @@
+import { Flags } from '@oclif/core';
+import path from 'node:path';
+import { BaseCommand } from '../../base-command.js';
+import { buildHandlers } from '../../build.js';
+export default class Build extends BaseCommand {
+    static args = {};
+    static description = 'build and validate a LiquidMetal.AI project';
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    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' }),
+    };
+    async run() {
+        const apps = await this.loadManifest();
+        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);
+    }
+}

package/dist/config.d.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+export declare const ConfigSchema: z.ZodObject<{
+    versionId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    versionId: string;
+}, {
+    versionId: string;
+}>;
+export type Config = z.infer<typeof ConfigSchema>;
+export declare const defaultConfig: Config;
+export declare function loadConfig(configPath: string): Promise<Config>;
+export declare function saveConfig(configPath: string, config: Config): Promise<void>;
+//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,YAAY;;;;;;EAEvB,CAAC;AAEH,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAElD,eAAO,MAAM,aAAa,EAAE,MAE3B,CAAC;AAKF,wBAAsB,UAAU,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAUpE;AAGD,wBAAsB,UAAU,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAOlF"}

package/dist/config.js

@@ -0,0 +1,34 @@
+import { readFile, writeFile } from 'fs/promises';
+import * as path from 'path';
+import { z } from 'zod';
+import { ensureDirectory } from './index.js';
+export const ConfigSchema = z.object({
+    versionId: z.string(),
+});
+export const defaultConfig = {
+    versionId: '01j6jj6hs588hee9rzw9pqe9d4',
+};
+// loadConfig reads the configuration file at path and always returns
+// an object that conforms to the ConfigSchema, even if it's empty. If
+// the file exists, that just implies an empty config.
+export async function loadConfig(configPath) {
+    let configFileContents;
+    try {
+        configFileContents = await readFile(configPath, {
+            encoding: 'utf-8',
+        });
+        return ConfigSchema.parse(JSON.parse(configFileContents));
+    }
+    catch {
+        return defaultConfig;
+    }
+}
+// saveConfig writes the given config object to the file at path.
+export async function saveConfig(configPath, config) {
+    // Create the path to the file if it doesn't exist; make directories as needed.
+    await ensureDirectory(path.dirname(configPath));
+    const configJson = JSON.stringify(config, null, 2);
+    await writeFile(configPath, configJson, {
+        encoding: 'utf-8',
+    });
+}

package/dist/config.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=config.test.d.ts.map

package/dist/config.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.test.d.ts","sourceRoot":"","sources":["../src/config.test.ts"],"names":[],"mappings":""}

package/dist/config.test.js

@@ -0,0 +1,24 @@
+import * as fs from 'node:fs/promises';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { expect, test } from 'vitest';
+import { loadConfig, saveConfig } from './config.js';
+test('loading missing config returns default/base config', async () => {
+    const configPath = '/tmp/this-never-exists-config.json';
+    const config = await loadConfig(configPath);
+    expect(config).toEqual({
+        versionId: '01j6jj6hs588hee9rzw9pqe9d4',
+    });
+});
+test('save/load config', async () => {
+    // Make a temp directory and write a config file to it.
+    const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'config-test'));
+    const configPath = path.join(tempDir, 'config.json');
+    await saveConfig(configPath, {
+        versionId: 'test-version-id',
+    });
+    const config = await loadConfig(configPath);
+    expect(config).toEqual({
+        versionId: 'test-version-id',
+    });
+});

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+import { ServiceType } from '@bufbuild/protobuf';
+import { PromiseClient } from '@connectrpc/connect';
+import { Application } from '@liquidmetal-ai/drizzle/appify/build';
+import { RainbowAuthService } from '@liquidmetal-ai/drizzle/liquidmetal/v1alpha1/rainbow_auth_connect';
+import { RaindropState } from '@liquidmetal-ai/drizzle/liquidmetal/v1alpha1/raindrop_pb';
+export { run } from '@oclif/core';
+export declare function configFromAppFile(appFile: string): Promise<Application[]>;
+export declare function joinPath(...parts: string[]): string;
+export declare function useClient<T extends ServiceType>(service: T, baseUrl: string): PromiseClient<T>;
+export declare function createAuthenticatingClient<T extends ServiceType>(service: T, configDir: string, rainbowAuth: PromiseClient<typeof RainbowAuthService>): Promise<{
+    client: PromiseClient<T>;
+    userId: string;
+    organizationId: string;
+}>;
+export declare function readState(configDir: string): Promise<RaindropState>;
+export declare function replaceState(configDir: string, state: RaindropState): Promise<void>;
+export declare function ensureDirectory(dir: string): Promise<void>;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,EAAoC,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEtF,OAAO,EAAE,WAAW,EAAE,MAAM,sCAAsC,CAAC;AAEnE,OAAO,EAAE,kBAAkB,EAAE,MAAM,mEAAmE,CAAC;AAEvG,OAAO,EAAE,aAAa,EAAE,MAAM,0DAA0D,CAAC;AAKzF,OAAO,EAAE,GAAG,EAAE,MAAM,aAAa,CAAC;AAElC,wBAAsB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC,CAG/E;AAGD,wBAAgB,QAAQ,CAAC,GAAG,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,CAEnD;AAGD,wBAAgB,SAAS,CAAC,CAAC,SAAS,WAAW,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,EAAE,MAAM,GAAG,aAAa,CAAC,CAAC,CAAC,CAM9F;AA8FD,wBAAsB,0BAA0B,CAAC,CAAC,SAAS,WAAW,EACpE,OAAO,EAAE,CAAC,EACV,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,aAAa,CAAC,OAAO,kBAAkB,CAAC,GACpD,OAAO,CAAC;IAAE,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,cAAc,EAAE,MAAM,CAAA;CAAE,CAAC,CAkB/E;AAID,wBAAsB,SAAS,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,CAUzE;AAED,wBAAsB,YAAY,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CASzF;AAGD,wBAAsB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAUhE"}

package/dist/index.js

@@ -0,0 +1,140 @@
+import { createPromiseClient } from '@connectrpc/connect';
+import { createConnectTransport } from '@connectrpc/connect-web';
+import { mustManifestFromString } from '@liquidmetal-ai/drizzle/appify/index';
+import { RaindropState } from '@liquidmetal-ai/drizzle/liquidmetal/v1alpha1/raindrop_pb';
+import { Mutex } from 'async-mutex';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+export { run } from '@oclif/core';
+export async function configFromAppFile(appFile) {
+    const contents = await fs.readFile(appFile, 'utf8');
+    return mustManifestFromString(contents);
+}
+// joinPath joins path parts and removes any duplicate slashes.
+export function joinPath(...parts) {
+    return parts.join('/').replace(/\/+/g, '/');
+}
+// useClient returns a promise client for the given service at baseUrl.
+export function useClient(service, baseUrl) {
+    const transport = createConnectTransport({
+        baseUrl,
+    });
+    return createPromiseClient(service, transport);
+}
+const accessTokenAndRefreshMutex = new Mutex();
+// bearerTokenAndRefresh returns an access token for the currently selected
+// organization based on the raindrop state found in the config directory. If
+// the access token is expired, the refresh token is used to generate a new
+// bearer token.
+async function bearerTokenAndRefresh(configDir, rainbowAuth) {
+    // utilize a mutex to probe if the refresh token is expired and to execute
+    // refreshing as invoking refresh multiple times with the same refresh token
+    // will invalidate the token.
+    return await accessTokenAndRefreshMutex.runExclusive(async () => {
+        const state = await readState(configDir);
+        if (!state.currentOrganizationId) {
+            throw new Error('not logged in');
+        }
+        const token = state.organizationIdToBearerToken[state.currentOrganizationId];
+        if (!token) {
+            throw new Error('no credentials set for current organization');
+        }
+        if (!token.accessTokenExpiresAt) {
+            throw new Error('accessTokenExpiresAt at not set');
+        }
+        const expiresAtBuffered = new Date(token.accessTokenExpiresAt.toDate().getTime() - 1000);
+        if (expiresAtBuffered.getTime() < Date.now()) {
+            const next = await rainbowAuth.refreshAccessToken({
+                ...token,
+            });
+            if (!next.bearerToken) {
+                throw new Error('unable to refresh login');
+            }
+            state.organizationIdToBearerToken[state.currentOrganizationId] = next.bearerToken;
+            await replaceState(configDir, state);
+            return next.bearerToken;
+        }
+        return token;
+    });
+}
+// createAuthenticateInterceptor returns a connect rpc interceptor which ensures
+// that the user is logged in with an active access token and automatically
+// refreshes the access tokens when making requests.
+async function createAuthenticateInterceptor(service, configDir, rainbowAuth) {
+    const { userId, organizationId, catalogServiceBaseUrl } = await bearerTokenAndRefresh(configDir, rainbowAuth);
+    const interceptor = (next) => async (req) => {
+        const { accessToken } = await bearerTokenAndRefresh(configDir, rainbowAuth);
+        req.header.set('Authorization', `Bearer ${accessToken}`);
+        return await next(req);
+    };
+    let baseUrl = '';
+    switch (service.typeName) {
+        case 'liquidmetal.v1alpha1.CatalogService':
+            baseUrl = catalogServiceBaseUrl;
+            if (process.env.RAINDROP_CATALOG_API_BASE_URL) {
+                baseUrl = process.env.RAINDROP_CATALOG_API_BASE_URL;
+                // Prepend missing protocol if missing
+                if (!baseUrl.match(/^http(s):\/\//)) {
+                    baseUrl = `https://${baseUrl}`;
+                }
+            }
+            break;
+        default:
+            throw new Error(`unable to determine baseUrl for service=${service.typeName}`);
+    }
+    return {
+        interceptor,
+        userId,
+        organizationId,
+        baseUrl,
+    };
+}
+// createAuthenticatingClient should be used for instantiating any connect rpc
+// client that needs to authenticate the requests.
+export async function createAuthenticatingClient(service, configDir, rainbowAuth) {
+    const { interceptor: authenticate, baseUrl, userId, organizationId, } = await createAuthenticateInterceptor(service, configDir, rainbowAuth);
+    const transport = createConnectTransport({
+        baseUrl,
+        interceptors: [authenticate],
+    });
+    return {
+        client: createPromiseClient(service, transport),
+        userId,
+        organizationId,
+    };
+}
+const configBasename = 'raindrop.json';
+export async function readState(configDir) {
+    const filename = path.join(configDir, configBasename);
+    try {
+        await fs.access(filename, fs.constants.F_OK);
+    }
+    catch {
+        await replaceState(configDir, new RaindropState({}));
+    }
+    const data = await fs.readFile(filename, { encoding: 'utf8' });
+    return RaindropState.fromJsonString(data);
+}
+export async function replaceState(configDir, state) {
+    const filename = path.join(configDir, configBasename);
+    const data = state.toJsonString({
+        prettySpaces: 2,
+    });
+    // Ensure config directory exists as well
+    await ensureDirectory(configDir);
+    await fs.writeFile(filename, data, 'utf8');
+}
+// ensureDirectory ensures that the directory exists at the given path
+export async function ensureDirectory(dir) {
+    try {
+        await fs.stat(dir);
+    }
+    catch (e) {
+        if (e instanceof Error && e.message.indexOf('ENOENT') > -1) {
+            await fs.mkdir(dir, { recursive: true });
+        }
+        else {
+            throw e;
+        }
+    }
+}

package/dist/index.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.test.d.ts.map

package/dist/index.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.test.d.ts","sourceRoot":"","sources":["../src/index.test.ts"],"names":[],"mappings":""}

package/dist/index.test.js

@@ -0,0 +1,4 @@
+import { expect, test } from 'vitest';
+test('noop', () => {
+    expect(true).toBe(true);
+});

package/dist/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../src/base-command.ts","../src/build.test.ts","../src/build.ts","../src/codegen.test.ts","../src/codegen.ts","../src/config.test.ts","../src/config.ts","../src/index.test.ts","../src/index.ts","../src/commands/auth/list.ts","../src/commands/auth/login.ts","../src/commands/auth/logout.ts","../src/commands/auth/select.ts","../src/commands/build/branch.ts","../src/commands/build/delete.ts","../src/commands/build/deploy.ts","../src/commands/build/find.ts","../src/commands/build/generate.ts","../src/commands/build/init.ts","../src/commands/build/list.ts","../src/commands/build/start.ts","../src/commands/build/stop.ts","../src/commands/build/token.ts","../src/commands/build/upload.ts","../src/commands/build/validate.ts","../src/commands/build/env/get.ts","../src/commands/build/env/set.ts"],"version":"5.6.2"}