@njdamstra/appwrite-utils-cli 1.8.9 → 1.10.0

package/dist/config/yamlConfig.js

@@ -1,702 +0,0 @@
-import { z } from "zod";
-import yaml from "js-yaml";
-import fs from "fs";
-import path from "path";
-import { AppwriteConfigSchema, RuntimeSchema, FunctionScopes, FunctionSpecifications, permissionsSchema, PermissionToAppwritePermission } from "@njdamstra/appwrite-utils";
-import { shouldIgnoreDirectory } from "../utils/directoryUtils.js";
-import { MessageFormatter } from "../shared/messageFormatter.js";
-const YamlConfigSchema = z.object({
-    appwrite: z.object({
-        endpoint: z.string().default("https://cloud.appwrite.io/v1"),
-        project: z.string(),
-        key: z.string(),
-        // Session authentication support
-        sessionCookie: z.string().optional(),
-        authMethod: z.enum(["session", "apikey", "auto"]).optional().default("auto"),
-        sessionMetadata: z.object({
-            email: z.string().optional(),
-            expiresAt: z.string().optional(),
-        }).optional(),
-    }),
-    logging: z
-        .object({
-        enabled: z.boolean().default(false),
-        level: z.enum(["error", "warn", "info", "debug"]).default("info"),
-        directory: z.string().optional(),
-        console: z.boolean().default(false),
-    })
-        .optional()
-        .default({ enabled: false, level: "info", console: false }),
-    backups: z
-        .object({
-        enabled: z.boolean().default(true),
-        interval: z.number().default(3600),
-        retention: z.number().default(30),
-        cleanup: z.boolean().default(true),
-    })
-        .optional()
-        .default({ enabled: true, interval: 3600, retention: 30, cleanup: true }),
-    data: z
-        .object({
-        enableMockData: z.boolean().default(false),
-        documentBucketId: z.string().default("documents"),
-        usersCollectionName: z.string().default("Members"),
-        importDirectory: z.string().default("importData"),
-    })
-        .optional()
-        .default({
-        enableMockData: false,
-        documentBucketId: "documents",
-        usersCollectionName: "Members",
-        importDirectory: "importData",
-    }),
-    schemas: z
-        .object({
-        outputDirectory: z.string().default("schemas"),
-        yamlSchemaDirectory: z.string().default(".yaml_schemas"),
-        collectionsDirectory: z.string().default("collections"),
-        tablesDirectory: z.string().default("tables"),
-    })
-        .optional()
-        .default({
-        outputDirectory: "schemas",
-        yamlSchemaDirectory: ".yaml_schemas",
-        collectionsDirectory: "collections",
-        tablesDirectory: "tables",
-    }),
-    migrations: z
-        .object({
-        enabled: z.boolean().default(false),
-    })
-        .optional()
-        .default({
-        enabled: true,
-    }),
-    databases: z
-        .array(z.object({
-        id: z.string(),
-        name: z.string(),
-        bucket: z
-            .object({
-            id: z.string(),
-            name: z.string(),
-            permissions: permissionsSchema,
-            fileSecurity: z.boolean().optional(),
-            enabled: z.boolean().optional(),
-            maximumFileSize: z.number().optional(),
-            allowedFileExtensions: z.array(z.string()).optional(),
-            compression: z.enum(["none", "gzip", "zstd"]).optional(),
-            encryption: z.boolean().optional(),
-            antivirus: z.boolean().optional(),
-        })
-            .optional(),
-    }))
-        .optional()
-        .default([
-        { id: "dev", name: "Development" },
-        { id: "main", name: "Main" },
-        { id: "staging", name: "Staging" },
-    ]),
-    buckets: z
-        .array(z.object({
-        id: z.string(),
-        name: z.string(),
-        permissions: permissionsSchema,
-        fileSecurity: z.boolean().optional(),
-        enabled: z.boolean().optional(),
-        maximumFileSize: z.number().optional(),
-        allowedFileExtensions: z.array(z.string()).optional(),
-        compression: z.enum(["none", "gzip", "zstd"]).optional(),
-        encryption: z.boolean().optional(),
-        antivirus: z.boolean().optional(),
-    }))
-        .optional()
-        .default([]),
-    functions: z
-        .array(z.object({
-        id: z.string(),
-        name: z.string(),
-        runtime: RuntimeSchema,
-        execute: z.array(z.string()).optional(),
-        events: z.array(z.string()).optional(),
-        schedule: z.string().optional(),
-        timeout: z.number().optional(),
-        enabled: z.boolean().optional(),
-        logging: z.boolean().optional(),
-        entrypoint: z.string().optional(),
-        commands: z.string().optional(),
-        scopes: z.array(FunctionScopes).optional(),
-        installationId: z.string().optional(),
-        providerRepositoryId: z.string().optional(),
-        providerBranch: z.string().optional(),
-        providerSilentMode: z.boolean().optional(),
-        providerRootDirectory: z.string().optional(),
-        templateRepository: z.string().optional(),
-        templateOwner: z.string().optional(),
-        templateRootDirectory: z.string().optional(),
-        templateBranch: z.string().optional(),
-        specification: FunctionSpecifications.optional(),
-        // Critical missing fields for function deployment
-        dirPath: z.string().optional(),
-        predeployCommands: z.array(z.string()).optional(),
-        deployDir: z.string().optional(),
-        ignore: z.array(z.string()).optional(),
-        templateVersion: z.string().optional(),
-    }))
-        .optional()
-        .default([]),
-});
-export const convertYamlToAppwriteConfig = (yamlConfig) => {
-    const appwriteConfig = {
-        appwriteEndpoint: yamlConfig.appwrite.endpoint,
-        appwriteProject: yamlConfig.appwrite.project,
-        appwriteKey: yamlConfig.appwrite.key,
-        // Session authentication support from YAML
-        sessionCookie: yamlConfig.appwrite.sessionCookie,
-        authMethod: yamlConfig.appwrite.authMethod || "auto",
-        sessionMetadata: yamlConfig.appwrite.sessionMetadata,
-        apiMode: "auto", // Default to auto-detect for dual API support
-        appwriteClient: null,
-        logging: {
-            enabled: yamlConfig.logging.enabled,
-            level: yamlConfig.logging.level,
-            logDirectory: yamlConfig.logging.directory,
-            console: yamlConfig.logging.console,
-        },
-        enableBackups: yamlConfig.backups.enabled,
-        backupInterval: yamlConfig.backups.interval,
-        backupRetention: yamlConfig.backups.retention,
-        enableBackupCleanup: yamlConfig.backups.cleanup,
-        enableMockData: yamlConfig.data.enableMockData,
-        documentBucketId: yamlConfig.data.documentBucketId,
-        usersCollectionName: yamlConfig.data.usersCollectionName,
-        schemaConfig: {
-            outputDirectory: yamlConfig.schemas.outputDirectory,
-            yamlSchemaDirectory: yamlConfig.schemas.yamlSchemaDirectory,
-            importDirectory: yamlConfig.data.importDirectory,
-            collectionsDirectory: yamlConfig.schemas.collectionsDirectory || "collections",
-            tablesDirectory: yamlConfig.schemas.tablesDirectory || "tables",
-        },
-        databases: yamlConfig.databases.map((db) => ({
-            $id: db.id,
-            name: db.name,
-            bucket: db.bucket
-                ? {
-                    $id: db.bucket.id,
-                    name: db.bucket.name,
-                    $permissions: PermissionToAppwritePermission(db.bucket.permissions),
-                    fileSecurity: db.bucket.fileSecurity || false,
-                    enabled: db.bucket.enabled || true,
-                    maximumFileSize: db.bucket.maximumFileSize || 30000000,
-                    allowedFileExtensions: db.bucket.allowedFileExtensions || [],
-                    compression: db.bucket.compression || "none",
-                    encryption: db.bucket.encryption || false,
-                    antivirus: db.bucket.antivirus || false,
-                }
-                : undefined,
-        })),
-        buckets: yamlConfig.buckets.map((bucket) => ({
-            $id: bucket.id,
-            name: bucket.name,
-            $permissions: PermissionToAppwritePermission(bucket.permissions),
-            fileSecurity: bucket.fileSecurity || false,
-            enabled: bucket.enabled || true,
-            maximumFileSize: bucket.maximumFileSize || 30000000,
-            allowedFileExtensions: bucket.allowedFileExtensions || [],
-            compression: bucket.compression || "none",
-            encryption: bucket.encryption || false,
-            antivirus: bucket.antivirus || false,
-        })),
-        functions: yamlConfig.functions?.map((func) => ({
-            $id: func.id,
-            name: func.name,
-            runtime: func.runtime,
-            execute: func.execute || [],
-            events: func.events || [],
-            schedule: func.schedule || "",
-            timeout: func.timeout || 15,
-            enabled: func.enabled || true,
-            logging: func.logging || true,
-            entrypoint: func.entrypoint || "",
-            commands: func.commands || "",
-            scopes: func.scopes || [],
-            installationId: func.installationId || "",
-            providerRepositoryId: func.providerRepositoryId || "",
-            providerBranch: func.providerBranch || "",
-            providerSilentMode: func.providerSilentMode || false,
-            providerRootDirectory: func.providerRootDirectory || "",
-            templateRepository: func.templateRepository || "",
-            templateOwner: func.templateOwner || "",
-            templateRootDirectory: func.templateRootDirectory || "",
-            templateBranch: func.templateBranch || "",
-            specification: func.specification || "s-0.5vcpu-512mb",
-            // Include critical missing fields for function deployment
-            dirPath: func.dirPath,
-            predeployCommands: func.predeployCommands,
-            deployDir: func.deployDir,
-            ignore: func.ignore,
-            templateVersion: func.templateVersion,
-        })),
-        collections: [], // Note: Collections are managed separately in YAML configs via individual collection files
-    };
-    return appwriteConfig;
-};
-/**
- * Load YAML config with optional session preservation
- * Maintains authentication priority: explicit session > YAML file > system prefs
- */
-export const loadYamlConfigWithSession = async (configPath, sessionOptions) => {
-    try {
-        const fileContent = fs.readFileSync(configPath, "utf8");
-        const yamlData = yaml.load(fileContent);
-        const yamlConfig = YamlConfigSchema.parse(yamlData);
-        const appwriteConfig = convertYamlToAppwriteConfig(yamlConfig);
-        // Apply session preservation if provided (explicit overrides take priority)
-        if (sessionOptions) {
-            if (sessionOptions.sessionCookie) {
-                appwriteConfig.sessionCookie = sessionOptions.sessionCookie;
-            }
-            if (sessionOptions.authMethod) {
-                appwriteConfig.authMethod = sessionOptions.authMethod;
-            }
-            if (sessionOptions.sessionMetadata) {
-                appwriteConfig.sessionMetadata = sessionOptions.sessionMetadata;
-            }
-        }
-        return appwriteConfig;
-    }
-    catch (error) {
-        if (error instanceof z.ZodError) {
-            MessageFormatter.error("YAML config validation failed", undefined, { prefix: "Config" });
-            error.issues.forEach((err) => {
-                MessageFormatter.error(`${err.path.join('.')} → ${err.message}`, undefined, { prefix: "Config" });
-            });
-        }
-        else {
-            MessageFormatter.error("Error loading YAML config", error instanceof Error ? error : undefined, { prefix: "Config" });
-            if (error instanceof Error && error.stack) {
-                MessageFormatter.debug("Stack trace", error.stack, { prefix: "Config" });
-            }
-        }
-        return null;
-    }
-};
-export const loadYamlConfig = async (configPath) => {
-    try {
-        const fileContent = fs.readFileSync(configPath, "utf8");
-        const yamlData = yaml.load(fileContent);
-        const yamlConfig = YamlConfigSchema.parse(yamlData);
-        return convertYamlToAppwriteConfig(yamlConfig);
-    }
-    catch (error) {
-        if (error instanceof z.ZodError) {
-            MessageFormatter.error("YAML config validation failed", undefined, { prefix: "Config" });
-            error.issues.forEach((err) => {
-                MessageFormatter.error(`${err.path.join('.')} → ${err.message}`, undefined, { prefix: "Config" });
-            });
-        }
-        else {
-            MessageFormatter.error("Error loading YAML config", error instanceof Error ? error : undefined, { prefix: "Config" });
-            if (error instanceof Error && error.stack) {
-                MessageFormatter.debug("Stack trace", error.stack, { prefix: "Config" });
-            }
-        }
-        return null;
-    }
-};
-export const findYamlConfig = (startDir) => {
-    // First check current directory for YAML configs
-    const possiblePaths = [
-        path.join(startDir, ".appwrite", "config.yaml"),
-        path.join(startDir, ".appwrite", "config.yml"),
-        path.join(startDir, ".appwrite", "appwriteConfig.yaml"),
-        path.join(startDir, ".appwrite", "appwriteConfig.yml"),
-        path.join(startDir, "appwrite.yaml"),
-        path.join(startDir, "appwrite.yml"),
-    ];
-    for (const configPath of possiblePaths) {
-        if (fs.existsSync(configPath)) {
-            return configPath;
-        }
-    }
-    // Recursively search subdirectories for .appwrite folders
-    const yamlConfigInSubdirs = findYamlConfigRecursive(startDir);
-    if (yamlConfigInSubdirs) {
-        return yamlConfigInSubdirs;
-    }
-    // Only check one level up to avoid infinite traversal
-    const parentDir = path.dirname(startDir);
-    if (parentDir !== startDir && path.basename(parentDir) !== 'node_modules') {
-        const parentPossiblePaths = [
-            path.join(parentDir, ".appwrite", "config.yaml"),
-            path.join(parentDir, ".appwrite", "config.yml"),
-            path.join(parentDir, ".appwrite", "appwriteConfig.yaml"),
-            path.join(parentDir, ".appwrite", "appwriteConfig.yml"),
-            path.join(parentDir, "appwrite.yaml"),
-            path.join(parentDir, "appwrite.yml"),
-        ];
-        for (const configPath of parentPossiblePaths) {
-            if (fs.existsSync(configPath)) {
-                return configPath;
-            }
-        }
-    }
-    return null;
-};
-const findYamlConfigRecursive = (dir, depth = 0) => {
-    // Limit search depth to prevent infinite recursion
-    if (depth > 5) {
-        return null;
-    }
-    if (shouldIgnoreDirectory(path.basename(dir))) {
-        return null;
-    }
-    try {
-        const entries = fs.readdirSync(dir, { withFileTypes: true });
-        for (const entry of entries) {
-            if (entry.isDirectory() && !shouldIgnoreDirectory(entry.name)) {
-                const fullPath = path.join(dir, entry.name);
-                // Check if this is an .appwrite directory
-                if (entry.name === ".appwrite") {
-                    const configPaths = [
-                        path.join(fullPath, "config.yaml"),
-                        path.join(fullPath, "config.yml"),
-                        path.join(fullPath, "appwriteConfig.yaml"),
-                        path.join(fullPath, "appwriteConfig.yml"),
-                    ];
-                    for (const configPath of configPaths) {
-                        if (fs.existsSync(configPath)) {
-                            return configPath;
-                        }
-                    }
-                }
-                // Recurse into other directories with increased depth
-                const result = findYamlConfigRecursive(fullPath, depth + 1);
-                if (result)
-                    return result;
-            }
-        }
-    }
-    catch (error) {
-        // Ignore directory access errors
-    }
-    return null;
-};
-export const generateYamlConfigTemplate = (outputPath) => {
-    const template = {
-        appwrite: {
-            endpoint: "https://cloud.appwrite.io/v1",
-            project: "YOUR_PROJECT_ID",
-            key: "YOUR_API_KEY",
-            authMethod: "auto",
-            // Optional session authentication (leave empty to use API key)
-            // sessionCookie: "session_cookie_from_appwrite_cli",
-        },
-        logging: {
-            enabled: false,
-            level: "info",
-            console: false,
-        },
-        backups: {
-            enabled: true,
-            interval: 3600,
-            retention: 30,
-            cleanup: true,
-        },
-        data: {
-            enableMockData: false,
-            documentBucketId: "documents",
-            usersCollectionName: "Members",
-            importDirectory: "importData",
-        },
-        schemas: {
-            outputDirectory: "schemas",
-            yamlSchemaDirectory: ".yaml_schemas",
-            collectionsDirectory: "collections",
-            tablesDirectory: "tables",
-        },
-        migrations: {
-            enabled: true,
-        },
-        databases: [
-            { id: "dev", name: "Development" },
-            { id: "main", name: "Main" },
-            { id: "staging", name: "Staging" },
-        ],
-        buckets: [],
-        functions: [],
-    };
-    let yamlContent = yaml.dump(template, {
-        indent: 2,
-        lineWidth: 120,
-        sortKeys: false,
-    });
-    // Add inline comments to the schemas section
-    yamlContent = yamlContent.replace(/schemas:\s*\n(\s*)outputDirectory: schemas\n(\s*)yamlSchemaDirectory: \.yaml_schemas\n(\s*)collectionsDirectory: collections\n(\s*)tablesDirectory: tables/, `schemas:
-$1outputDirectory: schemas
-$2yamlSchemaDirectory: .yaml_schemas
-$3# Directory for legacy Databases API collection definitions
-$3collectionsDirectory: collections
-$4# Directory for new TablesDB API table definitions
-$4tablesDirectory: tables`);
-    // Add schema reference header and documentation
-    const schemaReference = "# yaml-language-server: $schema=./.yaml_schemas/appwrite-config.schema.json\n";
-    const documentation = `# Appwrite Project Configuration
-#
-# Authentication Configuration:
-# - key: Standard API key authentication
-# - sessionCookie: Session cookie from Appwrite CLI authentication
-# - authMethod: "auto" (detects available method), "session" (prefer session), "apikey" (prefer API key)
-# - Priority: Explicit CLI args > YAML config > ~/.appwrite/prefs.json > Error
-#
-# Directory Configuration:
-# - collectionsDirectory: Use for legacy Databases API (default: "collections")
-# - tablesDirectory: Use for new TablesDB API (default: "tables")
-# - API mode is auto-detected based on server version, or set explicitly via apiMode
-#
-# For dual API support, both directories can coexist with different definitions
-
-`;
-    const finalContent = schemaReference + documentation + yamlContent;
-    fs.writeFileSync(outputPath, finalContent, "utf8");
-};
-/**
- * Converts AppwriteConfig back to YAML format and writes to file
- * @param configPath Path to the YAML config file
- * @param config The AppwriteConfig to convert and save
- */
-export const writeYamlConfig = async (configPath, config) => {
-    try {
-        // Convert AppwriteConfig back to YAML format
-        const yamlConfig = {
-            appwrite: {
-                endpoint: config.appwriteEndpoint,
-                project: config.appwriteProject,
-                key: config.appwriteKey,
-                // Include session authentication fields
-                sessionCookie: config.sessionCookie,
-                authMethod: config.authMethod || "auto",
-                sessionMetadata: config.sessionMetadata,
-            },
-            logging: {
-                enabled: config.logging?.enabled || false,
-                level: config.logging?.level || "info",
-                directory: config.logging?.logDirectory,
-                console: config.logging?.console || false,
-            },
-            backups: {
-                enabled: config.enableBackups !== false,
-                interval: config.backupInterval || 3600,
-                retention: config.backupRetention || 30,
-                cleanup: config.enableBackupCleanup !== false,
-            },
-            data: {
-                enableMockData: config.enableMockData || false,
-                documentBucketId: config.documentBucketId || "documents",
-                usersCollectionName: config.usersCollectionName || "Members",
-                importDirectory: config.schemaConfig?.importDirectory || "importData",
-            },
-            schemas: {
-                outputDirectory: config.schemaConfig?.outputDirectory || "schemas",
-                yamlSchemaDirectory: config.schemaConfig?.yamlSchemaDirectory || ".yaml_schemas",
-                collectionsDirectory: config.schemaConfig?.collectionsDirectory || "collections",
-                tablesDirectory: config.schemaConfig?.tablesDirectory || "tables",
-            },
-            migrations: {
-                enabled: true,
-            },
-            databases: config.databases?.map(db => ({
-                id: db.$id,
-                name: db.name,
-                bucket: db.bucket ? {
-                    id: db.bucket.$id,
-                    name: db.bucket.name,
-                    permissions: db.bucket.permissions || [],
-                    fileSecurity: db.bucket.fileSecurity,
-                    enabled: db.bucket.enabled,
-                    maximumFileSize: db.bucket.maximumFileSize,
-                    allowedFileExtensions: db.bucket.allowedFileExtensions,
-                    compression: db.bucket.compression,
-                    encryption: db.bucket.encryption,
-                    antivirus: db.bucket.antivirus,
-                } : undefined,
-            })) || [],
-            buckets: config.buckets?.map(bucket => ({
-                id: bucket.$id,
-                name: bucket.name,
-                permissions: bucket.permissions || [],
-                fileSecurity: bucket.fileSecurity,
-                enabled: bucket.enabled,
-                maximumFileSize: bucket.maximumFileSize,
-                allowedFileExtensions: bucket.allowedFileExtensions,
-                compression: bucket.compression,
-                encryption: bucket.encryption,
-                antivirus: bucket.antivirus,
-            })) || [],
-            functions: config.functions?.map(func => ({
-                id: func.$id,
-                name: func.name,
-                runtime: func.runtime,
-                execute: func.execute,
-                events: func.events,
-                schedule: func.schedule,
-                timeout: func.timeout,
-                enabled: func.enabled,
-                logging: func.logging,
-                entrypoint: func.entrypoint,
-                commands: func.commands,
-                scopes: func.scopes,
-                installationId: func.installationId,
-                providerRepositoryId: func.providerRepositoryId,
-                providerBranch: func.providerBranch,
-                providerSilentMode: func.providerSilentMode,
-                providerRootDirectory: func.providerRootDirectory,
-                templateRepository: func.templateRepository,
-                templateOwner: func.templateOwner,
-                templateRootDirectory: func.templateRootDirectory,
-                specification: func.specification,
-                // Include critical fields for function deployment
-                dirPath: func.dirPath,
-                predeployCommands: func.predeployCommands,
-                deployDir: func.deployDir,
-                ignore: func.ignore,
-                templateVersion: func.templateVersion,
-            })) || [],
-        };
-        // Write YAML config
-        const yamlContent = yaml.dump(yamlConfig, {
-            indent: 2,
-            lineWidth: 120,
-            sortKeys: false,
-        });
-        // Preserve schema reference if it exists
-        let finalContent = yamlContent;
-        if (fs.existsSync(configPath)) {
-            const existingContent = fs.readFileSync(configPath, "utf8");
-            const lines = existingContent.split('\n');
-            const schemaLine = lines.find(line => line.startsWith('# yaml-language-server:'));
-            const commentLine = lines.find(line => line.startsWith('# Appwrite Project Configuration'));
-            if (schemaLine) {
-                finalContent = schemaLine + '\n';
-                if (commentLine) {
-                    finalContent += commentLine + '\n';
-                }
-                finalContent += yamlContent;
-            }
-        }
-        else {
-            // Add schema reference for new files
-            const schemaReference = "# yaml-language-server: $schema=./.yaml_schemas/appwrite-config.schema.json\n";
-            finalContent = schemaReference + "# Appwrite Project Configuration\n" + yamlContent;
-        }
-        fs.writeFileSync(configPath, finalContent, "utf8");
-        MessageFormatter.success(`Updated YAML configuration at ${configPath}`, { prefix: "Config" });
-    }
-    catch (error) {
-        MessageFormatter.error("Error writing YAML config", error instanceof Error ? error : undefined, { prefix: "Config" });
-        throw error;
-    }
-};
-/**
- * Adds a new function to the YAML config file
- * @param configPath Path to the YAML config file
- * @param newFunction The function configuration to add
- */
-export const addFunctionToYamlConfig = async (configPath, newFunction) => {
-    try {
-        // Read current config
-        const fileContent = fs.readFileSync(configPath, "utf8");
-        const yamlData = yaml.load(fileContent);
-        // Initialize functions array if it doesn't exist
-        if (!yamlData.functions) {
-            yamlData.functions = [];
-        }
-        // Convert AppwriteFunction to YAML format
-        const yamlFunction = {
-            id: newFunction.$id,
-            name: newFunction.name,
-            runtime: newFunction.runtime,
-            execute: newFunction.execute || ["any"],
-            events: newFunction.events || [],
-            schedule: newFunction.schedule || "",
-            timeout: newFunction.timeout || 15,
-            enabled: newFunction.enabled !== false,
-            logging: newFunction.logging !== false,
-            entrypoint: newFunction.entrypoint || "",
-            commands: newFunction.commands || "",
-            scopes: newFunction.scopes || [],
-            specification: newFunction.specification || "s-0.5vcpu-512mb",
-            // Include critical fields for function deployment if they exist
-            ...(newFunction.dirPath && { dirPath: newFunction.dirPath }),
-            ...(newFunction.predeployCommands && { predeployCommands: newFunction.predeployCommands }),
-            ...(newFunction.deployDir && { deployDir: newFunction.deployDir }),
-            ...(newFunction.ignore && { ignore: newFunction.ignore }),
-            ...(newFunction.templateVersion && { templateVersion: newFunction.templateVersion }),
-        };
-        // Add new function
-        yamlData.functions.push(yamlFunction);
-        // Write back to file
-        const updatedYamlContent = yaml.dump(yamlData, {
-            indent: 2,
-            lineWidth: 120,
-            sortKeys: false,
-        });
-        // Preserve schema reference if it exists
-        const lines = fileContent.split('\n');
-        const schemaLine = lines.find(line => line.startsWith('# yaml-language-server:'));
-        let finalContent = updatedYamlContent;
-        if (schemaLine) {
-            finalContent = schemaLine + '\n' + updatedYamlContent;
-        }
-        fs.writeFileSync(configPath, finalContent, "utf8");
-        MessageFormatter.success(`Added function "${newFunction.name}" to YAML config`, { prefix: "Config" });
-    }
-    catch (error) {
-        MessageFormatter.error("Error adding function to YAML config", error instanceof Error ? error : undefined, { prefix: "Config" });
-        throw error;
-    }
-};
-/**
- * Extract session options from AppwriteConfig for YAML operations
- * Useful for preserving session state during config reloads
- */
-export const extractSessionOptionsFromConfig = (config) => {
-    return {
-        sessionCookie: config.sessionCookie,
-        authMethod: config.authMethod,
-        sessionMetadata: config.sessionMetadata,
-    };
-};
-/**
- * Create session-preserved YAML config operations
- * Maintains authentication state during config file updates
- */
-export const createSessionPreservingYamlConfig = (configPath, sessionOptions) => {
-    return {
-        load: () => loadYamlConfigWithSession(configPath, sessionOptions),
-        write: (config) => {
-            // Merge session options into config before writing
-            const enhancedConfig = {
-                ...config,
-                sessionCookie: sessionOptions.sessionCookie || config.sessionCookie,
-                authMethod: sessionOptions.authMethod || config.authMethod,
-                sessionMetadata: sessionOptions.sessionMetadata || config.sessionMetadata,
-            };
-            return writeYamlConfig(configPath, enhancedConfig);
-        },
-        addFunction: (func) => addFunctionToYamlConfig(configPath, func),
-    };
-};
-/**
- * Determine if YAML config has session authentication configured
- */
-export const hasYamlSessionAuth = (configPath) => {
-    try {
-        const fileContent = fs.readFileSync(configPath, "utf8");
-        const yamlData = yaml.load(fileContent);
-        return !!(yamlData?.appwrite?.sessionCookie && yamlData.appwrite.sessionCookie.trim());
-    }
-    catch (error) {
-        return false;
-    }
-};