lucy-cli 2.0.0-alpha.11 → 2.0.0-alpha.13

package/src/config.ts

@@ -1,23 +1,38 @@
-import { Context, Layer } from "effect"
+import { Context, Effect, Layer, Schema } from "effect"
 import { get_args } from "./args.js";
 import { dirname, join } from "path";
 import { fileURLToPath } from "url";
-import { readFileSync, existsSync } from "fs";
-type Action = 'init';
+import { lucySettings, LucySettings } from "./schemas/lucy.js";
+import os from 'os';
+import { Actions } from "./schemas/types.js";
+import { JsonSchema, veloSyncSettings, VeloSyncSettings, WixSDKSettings, wixSDKSettings } from "./schemas/index.js";
+import { FileSystem, Path } from "@effect/platform"
+import { NodeContext } from "@effect/platform-node/index";
 
-type Actions = {
-    action: Action;
-    type: 'velo' | 'expo' | 'blocks' | undefined;
-}
 export class Config extends Context.Tag("Config")<
     Config,
     {
         readonly config: {
             readonly action: Actions;
+            readonly force: boolean;
             readonly cwd: string;
             readonly packageRoot: string;
             readonly filesFolder: string;
-            readonly packageJson: any;
+            readonly veloSyncArguments?:{
+                    data?: string;
+                    collection?: string;
+                    schema?: string;
+                    dry: boolean;    
+            }
+            packageJson: any;
+            lucySettings: LucySettings;
+            readonly lucyHome: string;
+            templateDir: string;
+            templateFiles: string;
+            projectName: string;
+            defaultModuleBasePath: string;
+            veloSyncSettings?: VeloSyncSettings;
+            wixSDKSettings?: WixSDKSettings;
         }
     }
 >() {}
@@ -26,36 +41,102 @@ export class Config extends Context.Tag("Config")<
 // We can replicate it using `import.meta.url`.
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
-
-// Assuming your compiled output is in a 'dist' folder at the project root,
-// and your source `config.ts` is in `src`, the running `config.js` will be
-// in something like `dist/src`. To get to the package root, we go up two levels.
 const packageRoot = join(__dirname, "..");
 
+export const packageJsonName = "package.json";
+export const lucyJsonName = "lucy.json";
+export const wixSyncJsonName = "wix-sync.json";
+export const wixSDKSettingsJsonName = "wix-sdk-settings.json";
+export const syncDataName = 'sync-data';
+export const packageJsonPath = join(process.cwd(), packageJsonName);
+export const lucyJsonPath = join(process.cwd(), lucyJsonName);
+export const veloSyncJsonPath = join(process.cwd(), wixSyncJsonName);
+export const wixSDKSettingsJsonPath = join(process.cwd(), wixSDKSettingsJsonName);
+export const syncFilesSource= join(packageRoot, 'files', syncDataName);
+
+
 export const ConfigLayer = (args: Awaited<ReturnType<typeof get_args>>) => {
-    let packageJson = '{}';
-    const packageJsonPath = join(process.cwd(), 'package.json');
-    try {
-        if (existsSync(packageJsonPath)) {
-            const raw = readFileSync(packageJsonPath, 'utf-8');
-            packageJson = JSON.parse(raw);
-        }
-    } catch (error) {
-        console.error("Error reading package.json:", error);
-    }
-    return Layer.succeed(
+    return Layer.effect(
         Config,
-        Config.of({
-            config: {
-                action: {
-                    type: args.type,
-                    action: args._[0] as Action
-                },
-                cwd: process.cwd(),
-                packageRoot: packageRoot,
-                filesFolder: join(packageRoot, 'files'),
-                packageJson
+        Effect.gen(function* () {
+            const fs = yield* FileSystem.FileSystem;
+            const path = yield* Path.Path;
+            
+            let packageJson: any = {};
+            let lucyJson: LucySettings | undefined = undefined;
+            let veloSyncJson: VeloSyncSettings | undefined = undefined;
+            let wixSDKSettingsJson: WixSDKSettings | undefined = undefined;
+            // Read package.json
+            if (yield* fs.exists(packageJsonPath)) {
+                const raw = yield* fs.readFileString(packageJsonPath, 'utf-8');
+                packageJson = yield* Schema.decodeUnknown(JsonSchema)(raw);
+            }
+
+            // Read lucy.json
+            if (yield* fs.exists(lucyJsonPath)) {
+                const raw = yield* fs.readFileString(lucyJsonPath, 'utf-8');
+                const lucyJsonRaw = yield* Schema.decodeUnknown(JsonSchema)(raw);
+                lucyJson = yield* Schema.decodeUnknown(lucySettings)(lucyJsonRaw);
+            }
+
+            // Read wix-sync.json
+            if (yield* fs.exists(veloSyncJsonPath)) {
+                const raw = yield* fs.readFileString(veloSyncJsonPath, 'utf-8');
+                const veloSyncSettingsRaw = yield* Schema.decodeUnknown(JsonSchema)(raw);
+                veloSyncJson = yield* Schema.decodeUnknown(veloSyncSettings)(veloSyncSettingsRaw);
             }
-        })
+
+            // Read wix-sdk-settings.json
+            if (yield* fs.exists(wixSDKSettingsJsonPath)) {
+                const raw = yield* fs.readFileString(wixSDKSettingsJsonPath, 'utf-8');
+                const wixSDKSettingsRaw = yield* Schema.decodeUnknown(JsonSchema)(raw);
+                wixSDKSettingsJson = yield* Schema.decodeUnknown(wixSDKSettings)(wixSDKSettingsRaw);
+            }
+
+            const defaultModulePath = () => {
+                if (args.type === 'monorepo') {
+                    return join('packages');
+                }
+                return '';
+            };
+
+            return Config.of({
+                config: {
+                    action: {
+                        initType: args.initType,
+                        action: args._[0],
+                        tasksName: args.tasksName,
+                        syncAction: args.syncAction,
+                        wixSDKAction: args.wixSDKAction,
+                    },
+                    force: args.force === true ? true : false,
+                    cwd: process.cwd(),
+                    projectName: process.cwd().split('/').pop() || 'lucy-project',
+                    packageRoot,
+                    filesFolder: join(packageRoot, 'files'),
+                    packageJson,
+                    lucyHome: join(os.homedir(), '.lucy-cli'),
+                    veloSyncSettings: veloSyncJson,
+                    veloSyncArguments: {
+                        data: path.join(process.cwd(), args.input || ''),
+                        collection: args.collection,
+                        schema: path.join(process.cwd(), args.schema || ''),
+                        dry: args.d || false,
+                    },
+                    wixSDKSettings: wixSDKSettingsJson,
+                    lucySettings: lucyJson || {
+                        modules: {},
+                        devDependencies: {},
+                        dependencies: {},
+                        scripts: {},
+                        initialized: false,
+                        type: args.initType || 'velo',
+                    },
+                    templateFiles: '',
+                    templateDir: '',
+                    defaultModuleBasePath: defaultModulePath(),
+                }
+            });
+        }).pipe(Effect.provide(NodeContext.layer))
     );
-}
+}

package/src/error.ts

@@ -1,4 +1,3 @@
 import { Data } from "effect";
 
-export class AppError extends Data.TaggedError('AppError')<{cause: Error, message: string}> {}
-export class ScaleError extends Data.TaggedError('ScaleError')<{cause: Error, message: string}> {}
+export class AppError extends Data.TaggedError('AppError')<{cause: unknown, message: string}> {}

package/src/helpers.ts

@@ -1,3 +1,7 @@
+import os from 'os';
+import { spawnSync, exec } from 'child_process';
+import { logger } from './utils/logger.js';
+
 export function parse_error(error: unknown): Error {
     if (error instanceof Error) {
         return error;
@@ -6,4 +10,90 @@ export function parse_error(error: unknown): Error {
     } else {
         return new Error('Unknown error');
     }
+}
+
+
+/**
+ * Kill all processes matching a specific substring in their command, with a fallback for Windows.
+ * @param {string} processPattern - The substring to match (e.g., "wix:dev" or "@wix/cli/bin/wix.cjs").
+ */
+export function killAllProcesses(processPattern: string) {
+    const isWindows = os.platform() === 'win32';
+    const command = isWindows
+        ? `tasklist /FI "IMAGENAME eq node.exe" /FO CSV | findstr "${processPattern}"` // Adjust for Node.js processes
+        : `ps -eo pid,command | grep "${processPattern}" | grep -v grep`;
+
+    exec(command, (error, stdout, stderr) => {
+        if (error) {
+            logger.error(`Failed to find processes matching pattern: ${processPattern}`);
+            return;
+        }
+        if (stderr) {
+            logger.error(`Error output:')} ${stderr}`);
+        }
+        if (!stdout.trim()) {
+            logger.info(`No processes found matching pattern: ${processPattern}`);
+            return;
+        }
+
+        logger.info(`Found matching processes:\n${stdout}`);
+        const lines = stdout.trim().split('\n');
+        const pids = isWindows
+            ? lines.map(line => line.match(/"(\d+)"/)?.[1]) // Extract PID from Windows tasklist output
+            : lines.map(line => line.trim().split(/\s+/)[0]).filter(pid => !isNaN(Number(pid)));
+
+        pids.forEach(pid => {
+            if (!pid) return;
+            try {
+                const killCommand = isWindows
+                    ? `taskkill /PID ${pid} /T /F` // Forcefully terminate the process on Windows
+                    : `kill -SIGTERM ${pid}`;
+                
+                exec(killCommand, (killError) => {
+                    if (killError) {
+                        logger.error(`Failed to kill process with PID ${pid}: ${killError.message}`);
+                    } else {
+                        logger.success(`Killed process with PID: ${pid}`);
+                    }
+                });
+
+                // Schedule SIGKILL fallback for non-Windows platforms
+                if (!isWindows) {
+                    setTimeout(() => {
+                        try {
+                            process.kill(parseInt(pid, 10), 'SIGKILL');
+                            logger.kill(`Sent SIGKILL to process with PID: ${pid}`);
+                        } catch (killError: any) {
+                            if (killError.code === 'ESRCH') {
+                                logger.info(`Process with PID ${pid} already terminated.`);
+                            } else {
+                                logger.error(`Failed to send SIGKILL to process with PID ${pid}: ${killError.message}`);
+                            }
+                        }
+                    }, 10000);
+                }
+            } catch (err: any) {
+                logger.error(`Failed to kill process with PID ${pid}: ${err.message}`);
+            }
+        });
+    });
+}
+
+/**
+ * Clean up and run a command before exiting the process.
+ */
+export function cleanupWatchers() {
+    logger.info(`🧹 Cleaning up Watchman watchers...`);
+    const cwd = process.cwd();
+    const command = `watchman watch-del "${cwd}"`; // Adjust for Windows paths
+    exec(command, (error, stdout, stderr) => {
+        if (error) {
+            logger.error(`Failed to run cleanup command: ${error.message}`);
+            return;
+        }
+        if (stderr) {
+            logger.error(`Watchman stderr: ${stderr}`);
+        }
+        logger.info(`Watchman cleanup success: ${stdout}`);
+    });
 }

package/src/index.ts

@@ -1,36 +1,112 @@
 #!/usr/bin/env node
-import { Chunk, Duration, Effect, pipe, Schedule, Array, Ref } from "effect";
+import { Effect, pipe} from "effect";
 import { build_runtime } from "./runtime.js";
 import { get_args } from "./args.js";
 import 'dotenv/config'
 import { Config } from "./config.js";
-import { ServiceInspectState } from "./states.js";
-import { init } from "./init.js";
+import { init } from "./init/index.js";
+import { logger } from "./utils/logger.js";
+import { open } from "./commands/exec.js";
+import { tasks } from "./tasks/index.js";
+import { cleanupWatchers, killAllProcesses } from "./helpers.js";
+import { wix_sync } from "./wix-sync/index.js";
+import { wix_sdk } from "./wix-sdk/index.js";
 
+let exitReason: 'SIGINT' | 'SIGTERM' | 'none' = 'none'
+let needsCleanup = false;
+
+export function setNeedsCleanup(value: boolean) {
+    needsCleanup = value;
+}
+process.on('exit', (code) => {
+    if(!needsCleanup) return;
+    if(exitReason === 'none') {
+	    killAllProcesses('@wix/cli/bin/wix.cjs'); // Matches processes running the Wix CLI
+        killAllProcesses('wix:dev');   
+        cleanupWatchers();
+    }
+
+    logger.info(`🛑 Process exited with code: ${code}`);
+});
+
+process.on('SIGINT', () => {
+    exitReason = "SIGINT";
+
+	logger.info(`🐕 Received Ctrl+C (SIGINT), cleaning up...`);
+	killAllProcesses('@wix/cli/bin/wix.cjs'); // Matches processes running the Wix CLI
+	killAllProcesses('wix:dev');  
+    cleanupWatchers();
+    process.exit(); // Exit explicitly after handling
+});
+
+process.on('SIGTERM', () => {
+    exitReason = "SIGTERM";
+
+	logger.info(`🛑 Received termination signal (SIGTERM), cleaning up...`);
+	killAllProcesses('@wix/cli/bin/wix.cjs'); // Matches processes running the Wix CLI
+	killAllProcesses('wix:dev');  
+    cleanupWatchers();
+    process.exit(); // Exit explicitly after handling
+});
 
 const lucyCLI = pipe(
     Effect.gen(function* (_) {
         const config = yield* Config; 
-        config.config.action.type;
-        if (config.config.action.type === undefined) {
-            return yield* Effect.fail("No Params Provided");
-        }
+        const t = Config; 
         if (config.config.action.action === 'init') {
-            return yield* init();
+            return yield* init;
+        }
+        if (config.config.action.action === 'open') {
+            return yield* open;
+        }
+        if (config.config.action.action === 'task') {
+            return yield* tasks;
+        }
+        if (config.config.action.action === 'wix-sync') {
+            return yield* wix_sync;
+        }
+        if (config.config.action.action === 'wix-sdk') {
+            return yield* wix_sdk;
         }
-
-
     }),
+).pipe(
+    Effect.catchTags({
+        BadArgument: (error) => {
+            logger.error(JSON.stringify(error, null, 2));
+            return Effect.fail(new Error(error.message));
+        },
+        ParseError: (error) => {
+            logger.error("Failed to parse:", JSON.stringify(error, null, 2));
+            return Effect.fail(new Error("Failed to parse: " + error.message));
+        },
+        SystemError: (error) => {
+            logger.error("System error:", JSON.stringify(error, null, 2));
+            return Effect.fail(new Error("System error: " + error.message));
+        },   
+        AppError: (error) => {
+            logger.error("Application error:", JSON.stringify(error, null, 2));
+            return Effect.fail(new Error("Application error: " + error.message));
+        }
+    })
 )
 
 async function main() {
     const args = await get_args();
     const runtime= build_runtime(args);
     // The runtime will handle logging failures. This will catch unhandled defects.
-    await runtime.runPromise(lucyCLI)
+    const program = Effect.orDieWith(
+        lucyCLI,
+        (error) => new Error(`The application failed to run: ${error}`
+        )
+)
+    await runtime.runPromise(program)
 }
 
-main().catch((error) => {
-    console.error("An unexpected application error occurred:", error);
+main().then(() => {
+    process.exit(0);
+}).catch((error) => {
+    if (error instanceof Error) {
+        logger.error(error.message);
+    }
     process.exit(1);
 });

package/src/init/blocks.ts

@@ -0,0 +1,82 @@
+import { Effect, Schema } from "effect/index"
+import { Config, lucyJsonName } from "../config.js";
+import { Command, FileSystem, Path } from "@effect/platform"
+import { JsonSchema } from "../schemas/index.js";
+import { logger } from "../utils/logger.js";
+import { mergeAdditions, mergeLucySettings2PackageJson, setInitialized } from "../commands/edit.js";
+import { writeLucySettings, writePackageJson } from "../commands/write.js";
+import { copyTemplateFiles } from "../commands/copy.js";
+import { readPackageJson } from "../commands/read.js";
+import { execCommand } from "../commands/exec.js";
+import { installPackages } from "../commands/install.js";
+import { AppError } from "../error.js";
+import { cleanup } from "../commands/cleanup.js";
+import { checkForDirty } from "../commands/checks.js";
+
+export const init_blocks = () => {
+    return Effect.gen(function*() {
+        const config = yield* Config;
+        const fs = yield* FileSystem.FileSystem;
+        const path = yield* Path.Path;
+
+        logger.action("Initializing Blocks project...");
+
+        const configJsonRaw = yield* fs.readFile("wix.config.json").pipe(Effect.catchAll((error) => {
+            return Effect.succeed('{}');
+        }))
+        const configJson = Schema.decodeUnknownSync(JsonSchema)(configJsonRaw.toString()) as any;
+        const blocksAppReady = configJson.appId ? true : false;
+
+        yield* checkForDirty();
+
+        if(!blocksAppReady) {
+            const initBlocks = Command.make("npm", "create", "@wix/app@latest", config.config.projectName).pipe(
+                Command.stdin("inherit"),
+                Command.stdout("inherit"),
+                Command.stderr("inherit"),
+                Command.exitCode
+            )
+            if((yield* initBlocks) !== 0) {
+                yield* Effect.fail(new AppError({ message: "Failed to initialize Blocks project. Please check the error message above.", cause: new Error("Failed to initialize Blocks project") }));
+            }
+            const files = yield * fs.readDirectory(config.config.cwd, { recursive: false });
+
+            const allExcludes = ['.git', lucyJsonName];
+            const filteredFiles = files.filter(file => !allExcludes.includes(file));
+
+            const t = yield* fs.stat(filteredFiles[0]);
+            t.type === 'Directory'
+
+            const directories = yield* Effect.filter(
+                filteredFiles,
+                (file) => Effect.gen(function*() {
+                    const fullPath = path.join(config.config.cwd, file);
+                    const stat = yield* fs.stat(fullPath);
+                    return stat.type === "Directory";
+                })
+            );
+            const tempPath = directories[0];
+
+            const projectFiles = yield* fs.readDirectory(directories[0])
+            yield* Effect.forEach(
+                projectFiles.filter(file => file !== '.git'),
+                (file) => fs.copy(path.join(tempPath, file), path.join(config.config.cwd, file), { overwrite: true }),
+                { discard: true }
+            )
+            yield* fs.remove(tempPath, { recursive: true })
+        }
+
+        yield* readPackageJson;
+        yield* mergeLucySettings2PackageJson;
+        yield* mergeAdditions;
+        yield* writeLucySettings;
+        yield* writePackageJson;
+        yield* copyTemplateFiles;
+        yield* execCommand;
+        yield* installPackages;
+        yield* cleanup;
+        yield* setInitialized;
+
+        logger.success("Blocks project initialized successfully!");
+    })
+}

package/src/init/cargo.ts

@@ -0,0 +1,22 @@
+import { Effect } from "effect/index"
+import { logger } from "../utils/logger.js";
+import { writeLucySettings } from "../commands/write.js";
+import { copyTemplateFiles } from "../commands/copy.js";
+import { gitInit } from "../commands/git.js";
+import { checkForDirty } from "../commands/checks.js";
+import { setInitialized } from "../commands/edit.js";
+
+export const init_cargo = () => {
+    return Effect.gen(function*() {
+        logger.action("Initializing Cargo project...");
+
+        yield* checkForDirty();
+
+        yield* copyTemplateFiles;
+        yield* writeLucySettings;
+        yield* gitInit();
+        yield* setInitialized;
+        
+        logger.success("Cargo project initialized successfully!");
+    })
+}

package/src/init/expo.ts

@@ -0,0 +1,66 @@
+import { Effect, Schema } from "effect/index"
+import { Config } from "../config.js";
+import { Command, FileSystem, Path } from "@effect/platform"
+import { JsonSchema } from "../schemas/index.js";
+import { logger } from "../utils/logger.js";
+import { mergeAdditions, mergeLucySettings2PackageJson, setInitialized } from "../commands/edit.js";
+import { writeLucySettings, writePackageJson } from "../commands/write.js";
+import { copyTemplateFiles } from "../commands/copy.js";
+import { readPackageJson } from "../commands/read.js";
+import { execCommand } from "../commands/exec.js";
+import { installPackages } from "../commands/install.js";
+import { AppError } from "../error.js";
+import { cleanup } from "../commands/cleanup.js";
+import { checkForDirty } from "../commands/checks.js";
+
+export const init_expo = () => {
+    return Effect.gen(function*() {
+        const config = yield* Config;
+        const fs = yield* FileSystem.FileSystem;
+        const path = yield* Path.Path;
+
+        logger.action("Initializing Expo project...");
+
+        const appJsonRaw = yield* fs.readFile("app.json").pipe(Effect.catchAll((error) => {
+            return Effect.succeed('{}');
+        }))
+        const appJSON = Schema.decodeUnknownSync(JsonSchema)(appJsonRaw.toString()) as any;
+        const expoAppReady = appJSON.expo ? true : false;
+
+        yield* checkForDirty();
+
+        if(!expoAppReady) {
+            const initExpo = Command.make("npx", "create-expo-app@latest", config.config.projectName, "--template", "blank-typescript", "--no-install").pipe(
+                Command.stdout("inherit"),
+                Command.exitCode
+            )
+            if((yield* initExpo) !== 0) {
+                yield* Effect.fail(new AppError({ message: "Failed to initialize Expo project. Please check the error message above.", cause: new Error("Failed to initialize Expo project") }));
+            }
+
+            const tempPath = path.join(config.config.cwd, config.config.projectName)
+
+            const projectFiles = yield* fs.readDirectory(tempPath)
+            yield* Effect.forEach(
+                projectFiles.filter(file => file !== '.git'),
+                (file) => fs.copy(path.join(tempPath, file), path.join(config.config.cwd, file), { overwrite: true }),
+                { discard: true }
+            )
+            yield* fs.remove(tempPath, { recursive: true })
+        }
+
+        yield* readPackageJson;
+        yield* mergeLucySettings2PackageJson;
+        yield* mergeAdditions;
+        yield* writeLucySettings;
+        yield* writePackageJson;
+        yield* copyTemplateFiles;
+        yield* execCommand;
+        yield* installPackages;
+        yield* cleanup;
+        yield* setInitialized;
+        
+        logger.success("Expo project initialized successfully!");
+
+    })
+}

package/src/init/gitModules.ts

@@ -0,0 +1,15 @@
+import { Effect } from "effect/index"
+import { logger } from "../utils/logger.js";
+import { setInitialized } from "../commands/edit.js";
+import { gitInit } from "../commands/git.js";
+
+export const init_submodules = () => {
+    return Effect.gen(function*() {
+        logger.action("Initializing Git submodules project...");
+
+        yield* gitInit(true);
+        yield* setInitialized;
+        
+        logger.success("GIT initialized successfully!");
+    })
+}

package/src/init/index.ts

@@ -0,0 +1,63 @@
+import { Effect, Schema } from "effect/index"
+import { Config } from "../config.js";
+import { init_expo } from "./expo.js";
+import { selectTemplate } from "./templates.js";
+import Enquirer from "enquirer";
+import { AppError } from "../error.js";
+import { createLucyHome } from "../commands/home.js";
+import { readLucyJsonFromTemplate } from "../commands/read.js";
+import { init_monorepo } from "./monorepo.js";
+import { init_cargo } from "./cargo.js";
+import { init_blocks } from "./blocks.js";
+import { init_velo } from "./velo.js";
+import { init_submodules } from "./gitModules.js";
+import { init_tauri } from "./tauri.js";
+
+
+export const init = Effect.gen(function* (_) {
+    const config = yield* Config;
+    if(config.config.action.initType === undefined) {
+        return yield* Effect.fail(new AppError({ message: "No init type provided", cause: new Error("No init type provided") }));
+    }
+    yield* createLucyHome();
+    const projectName = config.config.cwd.split('/').pop() || 'expo-project';
+    const templateQuestion = new Enquirer();
+    const choice = yield* Effect.tryPromise({
+        try: () => templateQuestion.prompt({
+            type: 'input',
+            name: 'projectName',
+            message: 'Enter a project name',
+            initial: projectName,
+            validate: (value: string) => value.trim() !== '' ? true : 'Project name cannot be empty'
+        }),
+        catch: (e) => {
+            return new AppError({ cause: e, message: 'Error selecting template' });
+        }
+    })
+    const selectedName = yield* Schema.decodeUnknown(Schema.Struct({ projectName: Schema.String }))(choice)
+    config.config.projectName = selectedName.projectName.trim();
+    yield* selectTemplate();
+    yield* readLucyJsonFromTemplate;
+    if(config.config.action.initType === 'expo') {
+        return yield* init_expo();
+    }
+    if(config.config.action.initType === 'monorepo') {
+        return yield* init_monorepo();
+    }
+    if(config.config.action.initType === 'cargo') {
+        return yield* init_cargo();
+    }
+    if(config.config.action.initType === 'blocks') {
+        return yield* init_blocks();
+    }
+    if(config.config.action.initType === 'tauri') {
+        return yield* init_tauri();
+    }
+    if(config.config.action.initType === 'velo') {
+        return yield* init_velo();
+    }
+    if(config.config.action.initType === 'submodules') {
+        return yield* init_submodules();
+    }
+    yield* Effect.fail(new AppError({ message: `Unsupported init type: ${config.config.action.initType}`, cause: new Error(`Unsupported init type: ${config.config.action.initType}`) }));
+})