@claryai/cli 0.1.0

package/dist/handlers/lint/sarifFormatter.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatSarifForCli = formatSarifForCli;
+exports.getSarifSummary = getSarifSummary;
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const fs = tslib_1.__importStar(require("fs"));
+const path = tslib_1.__importStar(require("path"));
+/**
+ * Get a snippet of the file around the error location
+ */
+function getCodeSnippet(filePath, line, contextLines = 2) {
+    try {
+        const content = fs.readFileSync(filePath, 'utf8');
+        const lines = content.split('\n');
+        const startLine = Math.max(0, line - 1 - contextLines);
+        const endLine = Math.min(lines.length, line + contextLines);
+        return lines
+            .slice(startLine, endLine)
+            .map((lineText, idx) => {
+            const lineNum = startLine + idx + 1;
+            const prefix = lineNum === line ? '→ ' : '  ';
+            return `${prefix}${lineNum
+                .toString()
+                .padStart(3, ' ')} | ${lineText}`;
+        })
+            .join('\n');
+    }
+    catch {
+        return '';
+    }
+}
+/**
+ * Format SARIF results for CLI output
+ */
+function formatSarifForCli(sarifLog, searchPath) {
+    const output = [];
+    if (!sarifLog.runs || sarifLog.runs.length === 0) {
+        return chalk_1.default.green('\n✓ All Clary Code files are valid!\n');
+    }
+    const run = sarifLog.runs[0];
+    const results = run.results || [];
+    if (results.length === 0) {
+        return chalk_1.default.green('\n✓ All Clary Code files are valid!\n');
+    }
+    // Group results by file
+    const resultsByFile = new Map();
+    for (const result of results) {
+        const location = result.locations?.[0];
+        const uri = location?.physicalLocation?.artifactLocation?.uri;
+        if (uri) {
+            if (!resultsByFile.has(uri)) {
+                resultsByFile.set(uri, []);
+            }
+            resultsByFile.get(uri).push(result);
+        }
+    }
+    // Count stats
+    const totalFiles = resultsByFile.size;
+    output.push(chalk_1.default.red('\nValidation Errors:\n'));
+    // Format each file's errors
+    for (const [fileUri, fileResults] of resultsByFile.entries()) {
+        const relativePath = path.relative(searchPath, fileUri);
+        output.push(chalk_1.default.red.bold(`\n✗ ${relativePath}`));
+        for (const result of fileResults) {
+            const message = result.message.text;
+            const location = result.locations?.[0]?.physicalLocation;
+            const line = location?.region?.startLine;
+            const column = location?.region?.startColumn;
+            output.push(chalk_1.default.red(`\n  ${message}${line ? ` (line ${line})` : ''}`));
+            // Add clickable file link for IDEs
+            if (line) {
+                // Encode the URI properly for file:// protocol to handle special characters (#, ?, &, spaces, etc.)
+                const encodedPath = encodeURI(fileUri);
+                const fileLink = `file://${encodedPath}:${line}${column ? `:${column}` : ''}`;
+                output.push(chalk_1.default.dim(`  ${fileLink}`));
+            }
+            if (line && fs.existsSync(fileUri)) {
+                const snippet = getCodeSnippet(fileUri, line);
+                if (snippet) {
+                    output.push(chalk_1.default.dim(`\n${snippet}\n`));
+                }
+            }
+        }
+    }
+    output.push(chalk_1.default.red(`\nValidation failed for ${totalFiles} file${totalFiles > 1 ? 's' : ''}`));
+    return output.join('\n');
+}
+/**
+ * Get summary statistics from SARIF log
+ */
+function getSarifSummary(sarifLog) {
+    if (!sarifLog.runs || sarifLog.runs.length === 0) {
+        return { totalFiles: 0, totalErrors: 0, hasErrors: false };
+    }
+    const run = sarifLog.runs[0];
+    const results = run.results || [];
+    const uniqueFiles = new Set();
+    for (const result of results) {
+        const location = result.locations?.[0];
+        const uri = location?.physicalLocation?.artifactLocation?.uri;
+        if (uri) {
+            uniqueFiles.add(uri);
+        }
+    }
+    return {
+        totalFiles: uniqueFiles.size,
+        totalErrors: results.length,
+        hasErrors: results.length > 0,
+    };
+}

package/dist/handlers/lint.d.ts

@@ -0,0 +1,8 @@
+type LintOptions = {
+    path?: string;
+    verbose?: boolean;
+    format?: 'cli' | 'json';
+};
+export declare function lintHandler(options: LintOptions): Promise<void>;
+export {};
+//# sourceMappingURL=lint.d.ts.map

package/dist/handlers/lint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lint.d.ts","sourceRoot":"","sources":["../../src/handlers/lint.ts"],"names":[],"mappings":"AAiBA,KAAK,WAAW,GAAG;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,MAAM,CAAC,EAAE,KAAK,GAAG,MAAM,CAAC;CAC3B,CAAC;AAsOF,wBAAsB,WAAW,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAiJrE"}

package/dist/handlers/lint.js

@@ -0,0 +1,308 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lintHandler = lintHandler;
+const tslib_1 = require("tslib");
+const common_1 = require("@lightdash/common");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const fs = tslib_1.__importStar(require("fs"));
+const path = tslib_1.__importStar(require("path"));
+const uuid_1 = require("uuid");
+const YAML = tslib_1.__importStar(require("yaml"));
+const ajv_1 = require("../ajv");
+const analytics_1 = require("../analytics/analytics");
+const ajvToSarif_1 = require("./lint/ajvToSarif");
+const sarifFormatter_1 = require("./lint/sarifFormatter");
+const validateChartSchema = ajv_1.ajv.compile(common_1.chartAsCodeSchema);
+const validateDashboardSchema = ajv_1.ajv.compile(common_1.dashboardAsCodeSchema);
+const validateModelSchema = ajv_1.ajv.compile(common_1.modelAsCodeSchema);
+/**
+ * Find all YAML and JSON files in a path (file or directory).
+ * If a file path is provided, returns it if it's a .yml/.yaml/.json file.
+ * If a directory path is provided, recursively searches for all such files.
+ */
+function findLightdashCodeFiles(inputPath) {
+    const files = [];
+    // Check if the path is a file or directory
+    const stats = fs.statSync(inputPath);
+    if (stats.isFile()) {
+        // Single file case - check if it's a valid extension
+        const isYaml = inputPath.endsWith('.yml') || inputPath.endsWith('.yaml');
+        const isJson = inputPath.endsWith('.json');
+        if (isYaml || isJson) {
+            files.push(inputPath);
+        }
+        return files;
+    }
+    // Directory case - walk recursively
+    function walk(currentPath) {
+        const entries = fs.readdirSync(currentPath, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(currentPath, entry.name);
+            if (entry.isDirectory()) {
+                // Skip node_modules, .git, etc.
+                if (!entry.name.startsWith('.') &&
+                    entry.name !== 'node_modules' &&
+                    entry.name !== 'target') {
+                    walk(fullPath);
+                }
+            }
+            else if (entry.isFile()) {
+                const isYaml = entry.name.endsWith('.yml') || entry.name.endsWith('.yaml');
+                const isJson = entry.name.endsWith('.json');
+                if (isYaml || isJson) {
+                    files.push(fullPath);
+                }
+            }
+        }
+    }
+    walk(inputPath);
+    return files;
+}
+/**
+ * Build a map of JSON paths to their line/column positions in the source YAML/JSON file.
+ *
+ * This creates a Map<string, {line, column}> by traversing the YAML Abstract Syntax Tree (AST).
+ * For each YAML node encountered, we store its location keyed by its JSON path (e.g., '/metricQuery/filters').
+ *
+ * IMPORTANT: The map stores locations for ACTUAL YAML KEYS that exist in the file.
+ * It does NOT contain entries for:
+ * - Root path '/' (there's no root key in YAML)
+ * - Missing required properties that don't exist in the file
+ *
+ * @param fileContent - The raw YAML or JSON file content
+ * @param isJson - Whether the file is JSON (true) or YAML (false)
+ * @returns Object containing parsed data and the location map
+ */
+function buildLocationMap(fileContent, isJson) {
+    const locationMap = new Map();
+    if (isJson) {
+        // For JSON, parse normally (location map not populated - could be enhanced later)
+        const data = JSON.parse(fileContent);
+        return { data, locationMap };
+    }
+    // Parse YAML with the 'yaml' package to access the Abstract Syntax Tree (AST)
+    const doc = YAML.parseDocument(fileContent);
+    function traverse(node, jsonPath) {
+        if (!node)
+            return;
+        // Store location for this node
+        if (node.range) {
+            const [start] = node.range;
+            const lines = fileContent.substring(0, start).split('\n');
+            const line = lines.length;
+            const column = lines[lines.length - 1].length + 1;
+            locationMap.set(jsonPath, { line, column });
+        }
+        if (YAML.isMap(node)) {
+            for (const pair of node.items) {
+                if (YAML.isScalar(pair.key)) {
+                    const key = String(pair.key.value);
+                    const childPath = jsonPath
+                        ? `${jsonPath}/${key}`
+                        : `/${key}`;
+                    traverse(pair.value, childPath);
+                }
+            }
+        }
+        else if (YAML.isSeq(node)) {
+            for (let i = 0; i < node.items.length; i += 1) {
+                const childPath = `${jsonPath}/${i}`;
+                traverse(node.items[i], childPath);
+            }
+        }
+    }
+    traverse(doc.contents, '');
+    // Convert to plain JS object for validation
+    const data = doc.toJS();
+    return { data, locationMap };
+}
+/**
+ * Validate a single YAML or JSON file
+ */
+function validateFile(filePath) {
+    try {
+        // Read and parse file
+        const fileContent = fs.readFileSync(filePath, 'utf8');
+        const isJson = filePath.endsWith('.json');
+        const { data, locationMap } = buildLocationMap(fileContent, isJson);
+        if (!data || typeof data !== 'object') {
+            return {
+                filePath,
+                valid: false,
+                // Skip non-object files as they're not clary code
+            };
+        }
+        const dataObj = data;
+        // Check if this is a model (has type: "model", "model/v1beta", or "model/v1")
+        if (dataObj.type === 'model' ||
+            dataObj.type === 'model/v1beta' ||
+            dataObj.type === 'model/v1') {
+            const valid = validateModelSchema(data);
+            if (!valid && validateModelSchema.errors) {
+                return {
+                    filePath,
+                    valid: false,
+                    errors: validateModelSchema.errors,
+                    fileContent,
+                    locationMap,
+                    type: 'model',
+                };
+            }
+            return { filePath, valid: true, type: 'model' };
+        }
+        // Check if this is a chart (has version and metricQuery)
+        if (dataObj.version === 1 && dataObj.metricQuery && !dataObj.tiles) {
+            const valid = validateChartSchema(data);
+            if (!valid && validateChartSchema.errors) {
+                return {
+                    filePath,
+                    valid: false,
+                    errors: validateChartSchema.errors,
+                    fileContent,
+                    locationMap,
+                    type: 'chart',
+                };
+            }
+            return { filePath, valid: true, type: 'chart' };
+        }
+        // Check if this is a dashboard (has version and tiles)
+        if (dataObj.version === 1 && dataObj.tiles) {
+            const valid = validateDashboardSchema(data);
+            if (!valid && validateDashboardSchema.errors) {
+                return {
+                    filePath,
+                    valid: false,
+                    errors: validateDashboardSchema.errors,
+                    fileContent,
+                    locationMap,
+                    type: 'dashboard',
+                };
+            }
+            return { filePath, valid: true, type: 'dashboard' };
+        }
+        // Not a clary code file
+        return {
+            filePath,
+            valid: true, // Don't report non-lightdash files as errors
+        };
+    }
+    catch (error) {
+        // Parsing error - skip this file
+        return {
+            filePath,
+            valid: false,
+        };
+    }
+}
+async function lintHandler(options) {
+    const executionId = (0, uuid_1.v4)();
+    const startTime = Date.now();
+    const searchPath = path.resolve(options.path || process.cwd());
+    const outputFormat = options.format || 'cli';
+    let shouldExitWithError = false;
+    try {
+        // Check if path exists
+        if (!fs.existsSync(searchPath)) {
+            throw new Error(`Path does not exist: ${searchPath}`);
+        }
+        if (outputFormat === 'cli') {
+            console.log(chalk_1.default.dim(`Searching for Clary Code files in: ${searchPath}\n`));
+        }
+        // Find all YAML/JSON files
+        const codeFiles = findLightdashCodeFiles(searchPath);
+        const results = [];
+        if (codeFiles.length === 0) {
+            if (outputFormat === 'cli') {
+                console.log(chalk_1.default.yellow('No YAML/JSON files found in the specified path.'));
+            }
+        }
+        else {
+            if (options.verbose && outputFormat === 'cli') {
+                console.log(chalk_1.default.dim(`Found ${codeFiles.length} YAML/JSON files\n`));
+            }
+            // Validate each file
+            for (const file of codeFiles) {
+                const result = validateFile(file);
+                // Only track Clary Code files (models, charts, dashboards)
+                if (result.type) {
+                    results.push(result);
+                }
+            }
+            if (results.length === 0) {
+                if (outputFormat === 'cli') {
+                    console.log(chalk_1.default.yellow('No Clary Code files found.'));
+                    console.log(chalk_1.default.dim('Models must have type: model (or model/v1, model/v1beta), charts must have version: 1 + metricQuery, dashboards must have version: 1 + tiles'));
+                }
+            }
+            else {
+                // Convert to SARIF format
+                const invalidResults = results.filter((r) => !r.valid);
+                const validCount = results.length - invalidResults.length;
+                // Build SARIF report from invalid results
+                const sarifResults = invalidResults
+                    .filter((r) => r.errors && r.fileContent && r.type)
+                    .map((r) => ({
+                    filePath: r.filePath,
+                    errors: r.errors,
+                    fileContent: r.fileContent,
+                    locationMap: r.locationMap,
+                    schemaType: r.type,
+                }));
+                const sarifLog = (0, ajvToSarif_1.createSarifReport)(sarifResults);
+                // Output based on format
+                if (outputFormat === 'json') {
+                    console.log(JSON.stringify(sarifLog, null, 2));
+                }
+                else {
+                    // CLI format
+                    const summary = (0, sarifFormatter_1.getSarifSummary)(sarifLog);
+                    if (!summary.hasErrors) {
+                        console.log(chalk_1.default.green('\n✓ All Clary Code files are valid!\n'));
+                    }
+                    else {
+                        // Show summary
+                        console.log(chalk_1.default.bold(`\nValidated ${results.length} Clary Code files:`));
+                        console.log(chalk_1.default.green(`  ✓ ${validCount} valid`));
+                        console.log(chalk_1.default.red(`  ✗ ${summary.totalFiles} invalid`));
+                        // Show formatted errors (starts with newline, so we don't need extra spacing)
+                        console.log((0, sarifFormatter_1.formatSarifForCli)(sarifLog, searchPath));
+                    }
+                }
+                if (invalidResults.length > 0) {
+                    shouldExitWithError = true;
+                }
+            }
+        }
+        const invalidCount = results.filter((r) => !r.valid).length;
+        await analytics_1.LightdashAnalytics.track({
+            event: 'lint.completed',
+            properties: {
+                executionId,
+                filesScanned: codeFiles.length,
+                lightdashFilesFound: results.length,
+                validFiles: results.length - invalidCount,
+                invalidFiles: invalidCount,
+                chartFiles: results.filter((r) => r.type === 'chart').length,
+                dashboardFiles: results.filter((r) => r.type === 'dashboard')
+                    .length,
+                modelFiles: results.filter((r) => r.type === 'model').length,
+                outputFormat,
+                durationMs: Date.now() - startTime,
+            },
+        });
+    }
+    catch (e) {
+        await analytics_1.LightdashAnalytics.track({
+            event: 'lint.error',
+            properties: {
+                executionId,
+                error: (0, common_1.getErrorMessage)(e),
+                errorCategory: (0, analytics_1.categorizeError)(e),
+            },
+        });
+        throw e;
+    }
+    if (shouldExitWithError) {
+        process.exit(2);
+    }
+}

package/dist/handlers/listProjects.d.ts

@@ -0,0 +1,6 @@
+type ListProjectsOptions = {
+    verbose: boolean;
+};
+export declare const listProjectsHandler: (options: ListProjectsOptions) => Promise<void>;
+export {};
+//# sourceMappingURL=listProjects.d.ts.map

package/dist/handlers/listProjects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"listProjects.d.ts","sourceRoot":"","sources":["../../src/handlers/listProjects.ts"],"names":[],"mappings":"AAMA,KAAK,mBAAmB,GAAG;IACvB,OAAO,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAAU,SAAS,mBAAmB,kBAkDrE,CAAC"}

package/dist/handlers/listProjects.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listProjectsHandler = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@lightdash/common");
+const analytics_1 = require("../analytics/analytics");
+const globalState_1 = tslib_1.__importDefault(require("../globalState"));
+const styles = tslib_1.__importStar(require("../styles"));
+const apiClient_1 = require("./dbt/apiClient");
+const listProjectsHandler = async (options) => {
+    const startTime = Date.now();
+    let success = true;
+    globalState_1.default.setVerbose(options.verbose);
+    try {
+        const projects = await (0, apiClient_1.lightdashApi)({
+            method: 'GET',
+            url: `/api/v1/org/projects`,
+            body: undefined,
+        });
+        globalState_1.default.debug(`> List projects returned response: ${JSON.stringify(projects)}`);
+        // Filter out preview projects
+        const filteredProjects = projects.filter((project) => project.type !== common_1.ProjectType.PREVIEW);
+        if (filteredProjects.length === 0) {
+            console.error(styles.warning('No projects found.'));
+        }
+        else {
+            console.error(styles.bold(`\nProjects (${filteredProjects.length}):\n`));
+            filteredProjects.forEach((project) => {
+                console.error(`  ${styles.bold(project.name)}`);
+                console.error(`    UUID: ${project.projectUuid}`);
+                if (project.warehouseType) {
+                    console.error(`    Warehouse: ${project.warehouseType}`);
+                }
+                console.error('');
+            });
+        }
+    }
+    catch (e) {
+        success = false;
+        throw e;
+    }
+    finally {
+        await analytics_1.LightdashAnalytics.track({
+            event: 'command.executed',
+            properties: {
+                command: 'list-projects',
+                durationMs: Date.now() - startTime,
+                success,
+            },
+        });
+    }
+};
+exports.listProjectsHandler = listProjectsHandler;

package/dist/handlers/login/oauth.d.ts

@@ -0,0 +1,2 @@
+export declare const openBrowser: (url: string) => Promise<void>;
+//# sourceMappingURL=oauth.d.ts.map

package/dist/handlers/login/oauth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"oauth.d.ts","sourceRoot":"","sources":["../../../src/handlers/login/oauth.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,WAAW,GAAU,KAAK,MAAM,KAAG,OAAO,CAAC,IAAI,CAc3D,CAAC"}

package/dist/handlers/login/oauth.js

@@ -0,0 +1,27 @@
+"use strict";
+// Helper function to open browser
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openBrowser = void 0;
+const tslib_1 = require("tslib");
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const globalState_1 = tslib_1.__importDefault(require("../../globalState"));
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+const openBrowser = async (url) => {
+    try {
+        const { platform } = process;
+        if (platform === 'darwin') {
+            await execAsync(`open "${url}"`);
+        }
+        else if (platform === 'win32') {
+            await execAsync(`start "${url}"`);
+        }
+        else {
+            await execAsync(`xdg-open "${url}"`);
+        }
+    }
+    catch (error) {
+        globalState_1.default.debug(`> Could not open browser automatically: ${error}`);
+    }
+};
+exports.openBrowser = openBrowser;

package/dist/handlers/login/pat.d.ts

@@ -0,0 +1,2 @@
+export declare const generatePersonalAccessToken: (headers: Record<string, string>, url: string, hoursToExpire?: number) => Promise<string>;
+//# sourceMappingURL=pat.d.ts.map

package/dist/handlers/login/pat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pat.d.ts","sourceRoot":"","sources":["../../../src/handlers/login/pat.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,2BAA2B,GACpC,SAAS,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC/B,KAAK,MAAM,EACX,gBAAe,MAAY,KAC5B,OAAO,CAAC,MAAM,CAyBhB,CAAC"}

package/dist/handlers/login/pat.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generatePersonalAccessToken = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@lightdash/common");
+const node_fetch_1 = tslib_1.__importDefault(require("node-fetch"));
+const generatePersonalAccessToken = async (headers, url, hoursToExpire = 720) => {
+    const patUrl = new URL(`/api/v1/user/me/personal-access-tokens`, url).href;
+    const now = new Date();
+    const createToken = {
+        expiresAt: new Date(now.getTime() + hoursToExpire * 60 * 60 * 1000),
+        description: `Generated by OAuth on ${(0, common_1.formatDate)(now)}`,
+        autoGenerated: true,
+    };
+    const body = JSON.stringify(createToken);
+    const patResponse = await (0, node_fetch_1.default)(patUrl, {
+        method: 'POST',
+        body,
+        headers: {
+            'Content-Type': 'application/json',
+            ...headers,
+        },
+    });
+    if (!patResponse.ok) {
+        throw new common_1.AuthorizationError(`Failed to create PAT: ${patResponse.status} ${patResponse.statusText}`);
+    }
+    const patResponseBody = await patResponse.json();
+    const { token } = patResponseBody.results;
+    return token;
+};
+exports.generatePersonalAccessToken = generatePersonalAccessToken;

package/dist/handlers/login.d.ts

@@ -0,0 +1,15 @@
+type LoginOptions = {
+    /** Associated with a Personal Access Token or Service Account Token */
+    token?: string;
+    /** Email for password-based login */
+    email?: string;
+    /** Project UUID to select after login */
+    project?: string;
+    /** Port for the local OAuth callback server */
+    oauthPort?: number;
+    interactive?: boolean;
+    verbose: boolean;
+};
+export declare const login: (urlInput: string | undefined, options: LoginOptions) => Promise<void>;
+export {};
+//# sourceMappingURL=login.d.ts.map

package/dist/handlers/login.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"login.d.ts","sourceRoot":"","sources":["../../src/handlers/login.ts"],"names":[],"mappings":"AAkBA,KAAK,YAAY,GAAG;IACnB,uEAAuE;IACvE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,qCAAqC;IACrC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,yCAAyC;IACzC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,+CAA+C;IAC/C,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,OAAO,EAAE,OAAO,CAAC;CACjB,CAAC;AAwJF,eAAO,MAAM,KAAK,GACjB,UAAU,MAAM,GAAG,SAAS,EAC5B,SAAS,YAAY,kBAiJrB,CAAC"}