@liquidmetal-ai/raindrop 0.13.0 → 0.15.0

package/dist/commands/build/smartsql/setup.js

@@ -0,0 +1,169 @@
+import { Flags } from '@oclif/core';
+import chalk from 'chalk';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { BaseCommand } from '../../../base-command.js';
+import { renderTemplateFromFile, TEMPLATES_DIR } from '../../../codegen.js';
+export default class SmartSqlSetup extends BaseCommand {
+    static args = {};
+    static description = 'Add SmartSQL (PostgreSQL with natural language queries) to your Raindrop app';
+    static examples = [
+        `<%= config.bin %> <%= command.id %>
+Add SmartSQL with default name "my-database"
+
+<%= config.bin %> <%= command.id %> --name orders-db
+Add SmartSQL with custom name "orders-db"
+`,
+    ];
+    static flags = {
+        ...BaseCommand.HIDDEN_FLAGS,
+        name: Flags.string({
+            description: 'Name for the SmartSQL binding',
+            default: 'my-database',
+        }),
+        'dry-run': Flags.boolean({
+            description: 'Preview changes without applying them',
+            default: false,
+        }),
+    };
+    async run() {
+        // Check if binding already exists in manifest, use that name if found
+        const existingBinding = await this.findExistingBinding('smartsql');
+        const manifestName = existingBinding || this.flags.name;
+        const bindingName = manifestName.toUpperCase().replace(/-/g, '_');
+        const dryRun = this.flags['dry-run'];
+        // Find the first handler (service/actor/observer/task) to determine import path
+        const handlerName = await this.findFirstHandler();
+        // If no handler found, warn user and provide guidance
+        if (!handlerName) {
+            this.log(chalk.yellow.bold('⚠ No service, actor, observer, or task found in manifest'));
+            this.log('');
+            this.log('SmartSQL examples require a handler to generate type-safe code.');
+            this.log('Please add a handler to your manifest first:');
+            this.log('');
+            this.log(chalk.cyan('  service "api" {'));
+            this.log(chalk.cyan('    visibility = "public"'));
+            this.log(chalk.cyan('  }'));
+            this.log('');
+            this.log('Then run:');
+            this.log(chalk.bold('  raindrop build generate'));
+            this.log(chalk.bold('  raindrop build smartsql setup'));
+            return;
+        }
+        if (dryRun) {
+            this.log(chalk.blue.bold('DRY RUN - Preview of changes (no files will be modified)'));
+            this.log('');
+            this.log(chalk.blue('Would create:') + ' ' + chalk.bold('src/examples/smartsql-minimal.ts'));
+            this.log(chalk.dim('  - 55 lines of example code'));
+            this.log(chalk.dim('  - SQL queries, natural language queries, metadata management'));
+            this.log('');
+            this.log(chalk.blue('Would update:') + ' ' + chalk.bold('raindrop.manifest'));
+            this.log(chalk.dim(`  + smartsql "${manifestName}" {}`));
+            this.log('');
+            this.log(chalk.blue('Environment binding:') + ' ' + chalk.bold(`this.env.${bindingName}`));
+            this.log('');
+            this.log(chalk.yellow('Run without --dry-run to apply these changes'));
+            return;
+        }
+        try {
+            // Step 1: Create examples directory if it doesn't exist
+            const examplesDir = path.join(process.cwd(), 'src', 'examples');
+            await fs.mkdir(examplesDir, { recursive: true });
+            // Step 2: Generate example file
+            const exampleContent = await this.generateExampleFile(bindingName, handlerName);
+            const examplePath = path.join(examplesDir, 'smartsql-minimal.ts');
+            await fs.writeFile(examplePath, exampleContent);
+            this.log(chalk.green('✓') + ' Created ' + chalk.bold('src/examples/smartsql-minimal.ts'));
+            // Step 3: Update manifest
+            await this.updateManifest(manifestName);
+            this.log(chalk.green('✓') + ' Updated ' + chalk.bold('raindrop.manifest'));
+            // Step 4: Show next steps
+            this.log('');
+            this.log(chalk.bold.cyan('Next Steps:'));
+            this.log('');
+            this.log('1. Run ' + chalk.bold('raindrop build generate') + ' to update types');
+            this.log('2. Check out ' + chalk.bold('src/examples/smartsql-minimal.ts') + ' for example code');
+            this.log('3. Use ' + chalk.bold(`this.env.${bindingName}`) + ' in your handlers to query your database');
+            this.log('');
+            this.log(chalk.dim('Example usage:'));
+            this.log(chalk.dim(`  const result = await this.env.${bindingName}.executeQuery({`));
+            this.log(chalk.dim(`    sqlQuery: 'SELECT * FROM users',`));
+            this.log(chalk.dim(`    format: 'json'`));
+            this.log(chalk.dim(`  });`));
+            this.log('');
+        }
+        catch (error) {
+            this.error(`Failed to set up SmartSQL: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    async generateExampleFile(bindingName, handlerName) {
+        const templatePath = path.join(TEMPLATES_DIR, 'examples', 'smartsql-minimal.ts.hbs');
+        return renderTemplateFromFile(templatePath, { bindingName, handlerName });
+    }
+    async findExistingBinding(bindingType) {
+        const manifestPath = path.join(process.cwd(), 'raindrop.manifest');
+        try {
+            const content = await fs.readFile(manifestPath, 'utf-8');
+            const regex = new RegExp(`^\\s*${bindingType}\\s+"([^"]+)"`, 'm');
+            const match = content.match(regex);
+            return match?.[1] || null;
+        }
+        catch (_error) {
+            return null;
+        }
+    }
+    async findFirstHandler() {
+        const manifestPath = path.join(process.cwd(), 'raindrop.manifest');
+        try {
+            const content = await fs.readFile(manifestPath, 'utf-8');
+            // Look for first uncommented service, actor, observer, or task
+            const serviceMatch = content.match(/^\s*service\s+"([^"]+)"/m);
+            if (serviceMatch?.[1])
+                return serviceMatch[1];
+            const actorMatch = content.match(/^\s*actor\s+"([^"]+)"/m);
+            if (actorMatch?.[1])
+                return actorMatch[1];
+            const observerMatch = content.match(/^\s*observer\s+"([^"]+)"/m);
+            if (observerMatch?.[1])
+                return observerMatch[1];
+            const taskMatch = content.match(/^\s*task\s+"([^"]+)"/m);
+            if (taskMatch?.[1])
+                return taskMatch[1];
+            // Return null if no handler found
+            return null;
+        }
+        catch (_error) {
+            // Return null if can't read manifest
+            return null;
+        }
+    }
+    async updateManifest(manifestName) {
+        const manifestPath = path.join(process.cwd(), 'raindrop.manifest');
+        try {
+            let content = await fs.readFile(manifestPath, 'utf-8');
+            // Check if SmartSQL binding already exists
+            if (content.includes(`smartsql "${manifestName}"`)) {
+                this.log(chalk.yellow('⚠') + ' SmartSQL binding already exists in manifest');
+                return;
+            }
+            // Find the application block and add the smartsql binding
+            // Insert it after the opening brace of the application block
+            const appMatch = content.match(/application\s+"[^"]+"\s+\{/);
+            if (appMatch) {
+                const insertPos = appMatch.index + appMatch[0].length;
+                const binding = `\n  smartsql "${manifestName}" {}\n`;
+                content = content.slice(0, insertPos) + binding + content.slice(insertPos);
+                await fs.writeFile(manifestPath, content);
+            }
+            else {
+                throw new Error('Could not find application block in raindrop.manifest');
+            }
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                throw new Error('raindrop.manifest not found. Are you in a Raindrop project directory?');
+            }
+            throw error;
+        }
+    }
+}

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

@@ -8,7 +8,9 @@ export default class Build extends BaseCommand<typeof Build> {
         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>;
+        quick: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
+    private checkDependencies;
 }
 //# sourceMappingURL=validate.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../../src/commands/build/validate.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAgBpD,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;;;;;MAgBnB;IAEW,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;CAsBlC"}
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../../src/commands/build/validate.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAqCpD,MAAM,CAAC,OAAO,OAAO,KAAM,SAAQ,WAAW,CAAC,OAAO,KAAK,CAAC;IAC1D,OAAgB,IAAI,KAAM;IAE1B,OAAgB,WAAW,SAAiD;IAE5E,OAAgB,QAAQ,WAGtB;IAEF,OAAgB,KAAK;;;;;;MAoBnB;IAEW,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;YAmDnB,iBAAiB;CA2BhC"}

package/dist/commands/build/validate.js

@@ -1,23 +1,45 @@
 import { Flags } from '@oclif/core';
+import chalk from 'chalk';
 import { spawn } from 'node:child_process';
+import * as fs from 'node:fs/promises';
 import path from 'node:path';
 import { BaseCommand } from '../../base-command.js';
 import { buildHandlers } from '../../build.js';
 async function runTypeCheck(root) {
     return new Promise((resolve) => {
+        let output = '';
         const tsc = spawn('npx', ['tsc', '--noEmit'], {
             cwd: root,
-            stdio: 'inherit', // Inherit stdio to show compiler output in real-time
+            stdio: 'pipe', // Capture output to analyze errors
+        });
+        tsc.stdout?.on('data', (data) => {
+            output += data.toString();
+        });
+        tsc.stderr?.on('data', (data) => {
+            output += data.toString();
         });
         tsc.on('exit', (code) => {
-            resolve(code === 0);
+            const hasFrameworkError = output.includes('@liquidmetal-ai/raindrop-framework');
+            const hasHonoError = output.includes('hono');
+            // Print the TypeScript errors if check failed
+            if (code !== 0 && output) {
+                console.log(output);
+            }
+            resolve({
+                success: code === 0,
+                hasFrameworkError,
+                hasHonoError
+            });
         });
     });
 }
 export default class Build extends BaseCommand {
     static args = {};
     static description = 'build and validate a LiquidMetal.AI project';
-    static examples = ['<%= config.bin %> <%= command.id %>'];
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --quick  # Skip dependency checks',
+    ];
     static flags = {
         root: Flags.string({ char: 'r', description: 'root directory', required: false, default: process.cwd() }),
         manifest: Flags.string({
@@ -34,6 +56,10 @@ export default class Build extends BaseCommand {
             default: '.raindrop/config.json',
         }),
         output: Flags.string({ char: 'o', description: 'output directory', required: false, default: 'dist' }),
+        quick: Flags.boolean({
+            description: 'Skip dependency checks and run basic validation only',
+            default: false,
+        }),
     };
     async run() {
         const apps = await this.loadManifest();
@@ -41,17 +67,63 @@ export default class Build extends BaseCommand {
         if (version === null) {
             this.error('Failed to determine @liquidmetal-ai/raindrop-framework version; is it installed?', { exit: 1 });
         }
-        console.log(`Using @liquidmetal-ai/raindrop-framework version ${version}`);
+        console.log(chalk.blue(`✓ Using @liquidmetal-ai/raindrop-framework version ${version}`));
+        // Check package.json dependencies if not quick mode
+        if (!this.flags.quick) {
+            await this.checkDependencies();
+        }
         // Run TypeScript type checking
         console.log('Running type check...');
-        const typeCheckPassed = await runTypeCheck(this.flags.root);
-        if (!typeCheckPassed) {
-            this.error('Type check failed. Please fix the TypeScript errors before building.');
+        const typeCheckResult = await runTypeCheck(this.flags.root);
+        if (!typeCheckResult.success) {
+            console.log('');
+            console.log(chalk.red('Type check failed. Please fix the TypeScript errors before building.'));
+            if (typeCheckResult.hasFrameworkError) {
+                console.log('');
+                console.log(chalk.yellow('Framework import error detected. Try:'));
+                console.log(chalk.dim('   npm install'));
+                console.log(chalk.dim('   raindrop build generate'));
+                console.log(chalk.dim('   Or check your package.json for the correct framework version'));
+            }
+            if (typeCheckResult.hasHonoError) {
+                console.log('');
+                console.log(chalk.yellow('Hono import error detected. Try:'));
+                console.log(chalk.dim('   npm install hono'));
+            }
+            console.log('');
+            console.log(chalk.bold('For more help:'));
+            console.log(chalk.dim('   raindrop build features  # Discover available features'));
+            console.log(chalk.dim('   raindrop build smartmemory setup  # Get working examples'));
+            this.error('Validation failed');
         }
-        console.log('Type check passed');
+        console.log(chalk.green('✓ Type check passed'));
         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);
     }
+    async checkDependencies() {
+        try {
+            const packageJsonPath = path.join(this.flags.root, 'package.json');
+            const packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf-8'));
+            const frameworkDep = packageJson.dependencies?.['@liquidmetal-ai/raindrop-framework'];
+            const honoDep = packageJson.dependencies?.['hono'];
+            if (!frameworkDep) {
+                console.log(chalk.yellow('⚠️  @liquidmetal-ai/raindrop-framework not found in dependencies'));
+                console.log(chalk.dim('   Try: npm install @liquidmetal-ai/raindrop-framework'));
+                console.log('');
+            }
+            if (!honoDep) {
+                console.log(chalk.yellow('⚠️  hono not found in dependencies'));
+                console.log(chalk.dim('   Try: npm install hono'));
+                console.log('');
+            }
+            if (frameworkDep && honoDep) {
+                console.log(chalk.green('✓ Core dependencies present'));
+            }
+        }
+        catch (_error) {
+            console.log(chalk.yellow('⚠️  Could not check package.json dependencies'));
+        }
+    }
 }

package/dist/commands/build/workos/jwt.d.ts

@@ -0,0 +1,23 @@
+import { BaseCommand } from '../../../base-command.js';
+export default class Jwt extends BaseCommand<typeof Jwt> {
+    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>;
+        application: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'client-id': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'session-file': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        config: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        rainbowAuthService: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        raindropCatalogService: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        rainbowAuthToken: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        rainbowOrganizationId: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        rainbowUserId: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        sendVersionMetadata: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+    private fetchClientId;
+}
+//# sourceMappingURL=jwt.d.ts.map

package/dist/commands/build/workos/jwt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jwt.d.ts","sourceRoot":"","sources":["../../../../src/commands/build/workos/jwt.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAuDvD,MAAM,CAAC,OAAO,OAAO,GAAI,SAAQ,WAAW,CAAC,OAAO,GAAG,CAAC;IACtD,MAAM,CAAC,IAAI,KAAM;IAEjB,MAAM,CAAC,WAAW,SAAoE;IAEtF,MAAM,CAAC,QAAQ,WAUb;IAEF,MAAM,CAAC,KAAK;;;;;;;;;;;;;MA0BV;IAEI,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;YA6DZ,aAAa;CAsC5B"}

package/dist/commands/build/workos/jwt.js

@@ -0,0 +1,172 @@
+import { Flags } from '@oclif/core';
+import * as fs from 'node:fs/promises';
+import path from 'node:path';
+import { BaseCommand } from '../../../base-command.js';
+import { refreshToken } from '../../../lib/workos-test-server.js';
+/**
+ * Decode JWT payload without verification
+ */
+function decodeJWTPayload(token) {
+    try {
+        const parts = token.split('.');
+        if (parts.length !== 3) {
+            throw new Error('Invalid JWT format');
+        }
+        const payload = parts[1];
+        if (!payload) {
+            throw new Error('Invalid JWT format: missing payload');
+        }
+        const decoded = JSON.parse(Buffer.from(payload, 'base64url').toString());
+        return decoded;
+    }
+    catch (error) {
+        throw new Error(`Failed to decode JWT: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}
+/**
+ * Check if a JWT is expired
+ */
+function isTokenExpired(token) {
+    try {
+        const payload = decodeJWTPayload(token);
+        if (!payload.exp) {
+            // If no expiration, consider it valid
+            return false;
+        }
+        const now = Math.floor(Date.now() / 1000);
+        return payload.exp < now;
+    }
+    catch {
+        // If we can't decode it, consider it invalid/expired
+        return true;
+    }
+}
+/**
+ * Read session from file
+ */
+async function readSession(sessionFile) {
+    try {
+        const data = await fs.readFile(sessionFile, 'utf8');
+        return JSON.parse(data);
+    }
+    catch {
+        return null;
+    }
+}
+export default class Jwt extends BaseCommand {
+    static args = {};
+    static description = 'Get the JWT from the dev-login session (refreshing if expired)';
+    static examples = [
+        `<%= config.bin %> <%= command.id %>
+Get JWT from the default session file (.auth.json)
+
+<%= config.bin %> <%= command.id %> --session-file /path/to/.auth.json
+Get JWT from a specific session file
+
+<%= config.bin %> <%= command.id %> --client-id client_xxx
+Get JWT with explicit client ID for refresh
+`,
+    ];
+    static flags = {
+        ...BaseCommand.HIDDEN_FLAGS,
+        root: Flags.string({
+            description: 'root directory',
+            required: false,
+            default: process.cwd(),
+        }),
+        manifest: Flags.string({
+            description: 'project manifest',
+            required: false,
+            default: 'raindrop.manifest',
+        }),
+        application: Flags.string({
+            char: 'a',
+            description: 'application name',
+            required: false,
+        }),
+        'client-id': Flags.string({
+            description: 'WorkOS client ID (for token refresh)',
+            required: false,
+            env: 'WORKOS_CLIENT_ID',
+        }),
+        'session-file': Flags.string({
+            description: 'path to session file',
+            required: false,
+        }),
+    };
+    async run() {
+        const { root, 'client-id': clientIdFlag, 'session-file': sessionFileFlag } = this.flags;
+        // Determine session file path
+        const sessionFile = sessionFileFlag || path.join(root, '.auth.json');
+        // Read the session
+        const session = await readSession(sessionFile);
+        if (!session) {
+            this.error(`No session file found at ${sessionFile}. Run 'raindrop build workos env dev-login' first.`, { exit: 1 });
+        }
+        if (!session.access_token) {
+            this.error('Session file exists but contains no access token.', { exit: 1 });
+        }
+        let accessToken = session.access_token;
+        // Check if token is expired
+        if (isTokenExpired(accessToken)) {
+            // Token is expired, try to refresh it
+            if (!session.refresh_token) {
+                this.error('Token is expired and no refresh token is available. Run `raindrop build workos env dev-login` again.', { exit: 1 });
+            }
+            // Get client ID
+            let clientId = clientIdFlag;
+            if (!clientId) {
+                // Try to get from environment
+                try {
+                    const envInfo = await this.fetchClientId();
+                    clientId = envInfo;
+                }
+                catch (error) {
+                    const err = error;
+                    this.error(`Client ID required for token refresh. Provide --client-id or ensure WorkOS environment is attached.\nError: ${err.message}`, { exit: 1 });
+                }
+            }
+            // Refresh the token
+            try {
+                const refreshedSession = await refreshToken({
+                    clientId,
+                    sessionFile,
+                });
+                accessToken = refreshedSession.access_token;
+            }
+            catch (error) {
+                const err = error;
+                this.error(`Failed to refresh token: ${err.message}. Run \`raindrop build workos env dev-login\` again.`, { exit: 1 });
+            }
+        }
+        // Output the JWT to stdout
+        console.log(accessToken);
+    }
+    async fetchClientId() {
+        const { valueOf } = await import('@liquidmetal-ai/drizzle/appify/build');
+        // Load manifest to get application name
+        const apps = await this.loadManifest();
+        const app = apps.find((a) => valueOf(a.name) === this.flags.application) || apps[0];
+        if (!app) {
+            throw new Error('No application found in manifest. Specify --client-id.');
+        }
+        const applicationName = valueOf(app.name);
+        // Load config to get version ID
+        const config = await this.loadConfig();
+        const versionId = config.versionId;
+        if (!versionId) {
+            throw new Error('No version ID found. Deploy your application first with: raindrop build deploy');
+        }
+        const { client: workosService, userId, organizationId } = await this.workosIntegrationService();
+        const response = await workosService.getEnvironmentForApplication({
+            userId,
+            organizationId,
+            applicationName,
+            versionId,
+        });
+        if (!response.environment?.clientId) {
+            throw new Error(`No WorkOS environment attached to ${applicationName}. Attach one with: raindrop build workos env attach <env-name>`);
+        }
+        return response.environment.clientId;
+    }
+}

package/dist/commands/doctor.d.ts

@@ -0,0 +1,27 @@
+import { BaseCommand } from '../base-command.js';
+export default class Doctor extends BaseCommand<typeof Doctor> {
+    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>;
+        config: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        rainbowAuthService: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        raindropCatalogService: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        rainbowAuthToken: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        rainbowOrganizationId: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        rainbowUserId: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        sendVersionMetadata: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+    private promptForAIAgent;
+    private collectDiagnostics;
+    private collectVersionInfo;
+    private collectProjectInfo;
+    private collectAuthInfo;
+    private maskEmail;
+    private collectEnvironmentInfo;
+    private displayDiagnostics;
+}
+//# sourceMappingURL=doctor.d.ts.map

package/dist/commands/doctor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"doctor.d.ts","sourceRoot":"","sources":["../../src/commands/doctor.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AA2CjD,MAAM,CAAC,OAAO,OAAO,MAAO,SAAQ,WAAW,CAAC,OAAO,MAAM,CAAC;IAC5D,MAAM,CAAC,WAAW,SAAoE;IAEtF,MAAM,CAAC,QAAQ,WAIb;IAEF,MAAM,CAAC,KAAK;;;;;;;;;;;MAmBV;IAEI,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;YAqBZ,gBAAgB;YA8ChB,kBAAkB;YA0BlB,kBAAkB;YA4BlB,kBAAkB;YA6ClB,eAAe;IAiC7B,OAAO,CAAC,SAAS;IAgBjB,OAAO,CAAC,sBAAsB;IAiC9B,OAAO,CAAC,kBAAkB;CAyF3B"}