@digicroz/node-server-kit 1.0.0

package/dist/b2fPortalV3/moduleZodCreator.js

@@ -0,0 +1,41 @@
+import fs from "fs";
+import path from "path";
+export function createZodFiles(directoryPath) {
+    fs.readdir(directoryPath, (err, files) => {
+        if (err) {
+            console.error("Error reading directory:", err);
+            return;
+        }
+        files.forEach((file) => {
+            const filePath = path.join(directoryPath, file);
+            fs.stat(filePath, (err, stats) => {
+                if (err) {
+                    console.error("Error accessing file:", err);
+                    return;
+                }
+                if (stats.isDirectory()) {
+                    // Recursively call for subdirectories
+                    createZodFiles(filePath);
+                }
+                else if (file.endsWith(".ts") && !file.endsWith("Zod.ts")) {
+                    const newFileName = `${path.parse(file).name}Zod.ts`;
+                    const newFilePath = path.join(directoryPath, newFileName);
+                    if (!fs.existsSync(newFilePath)) {
+                        const newData = `export const ${path.parse(file).name}ZodSchema = {\n\t\n};\n`;
+                        fs.writeFile(newFilePath, newData, (err) => {
+                            if (err) {
+                                console.error("Error creating new file:", err);
+                            }
+                            else {
+                                console.log(`Created ${newFileName}`);
+                            }
+                        });
+                    }
+                    else {
+                        // console.log(`${newFileName} already exists, skipping...`);
+                    }
+                }
+            });
+        });
+    });
+}

package/dist/b2fPortalV3/stripExtensions.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Recursively finds all .ts files in the provided directory.
+ * @param dir The directory to search.
+ * @returns An array of full paths to .ts files.
+ */
+export declare function getTsFiles(dir: string): string[];
+/**
+ * Updates import/export statements in the given file by removing a trailing `.js` extension.
+ * Handles both static and dynamic import syntax.
+ * @param filePath Full path to the .ts file.
+ */
+export declare function updateImports(filePath: string): void;

package/dist/b2fPortalV3/stripExtensions.js

@@ -0,0 +1,51 @@
+import * as fs from "fs";
+import * as path from "path";
+/**
+ * Recursively finds all .ts files in the provided directory.
+ * @param dir The directory to search.
+ * @returns An array of full paths to .ts files.
+ */
+export function getTsFiles(dir) {
+    let results = [];
+    const entries = fs.readdirSync(dir);
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry);
+        const stat = fs.statSync(fullPath);
+        if (stat.isDirectory()) {
+            results = results.concat(getTsFiles(fullPath));
+        }
+        else if (stat.isFile() && fullPath.endsWith(".ts") && !fullPath.endsWith(".d.ts")) {
+            results.push(fullPath);
+        }
+    }
+    return results;
+}
+/**
+ * Updates import/export statements in the given file by removing a trailing `.js` extension.
+ * Handles both static and dynamic import syntax.
+ * @param filePath Full path to the .ts file.
+ */
+export function updateImports(filePath) {
+    const content = fs.readFileSync(filePath, "utf-8");
+    let updatedContent = content;
+    // Regular expression for static imports/exports e.g.:
+    // import ... from 'module'
+    // export ... from "module"
+    const staticRegex = /((?:import|export)(?:[\s\S]*?)from\s+)(['"])([^'"]+\.js)(\2)/g;
+    updatedContent = updatedContent.replace(staticRegex, (_match, before, quote, modulePath, _quote) => {
+        // Remove the trailing ".js" from the module path.
+        const newModulePath = modulePath.replace(/\.js$/, "");
+        return `${before}${quote}${newModulePath}${quote}`;
+    });
+    // Regular expression for dynamic imports e.g.:
+    // import('module')
+    const dynamicRegex = /(\bimport\(\s*)(['"])([^'"]+\.js)(\2)/g;
+    updatedContent = updatedContent.replace(dynamicRegex, (_match, before, quote, modulePath, _quote) => {
+        const newModulePath = modulePath.replace(/\.js$/, "");
+        return `${before}${quote}${newModulePath}${quote}`;
+    });
+    if (updatedContent !== content) {
+        fs.writeFileSync(filePath, updatedContent, "utf-8");
+        // console.log(`Updated: ${filePath}`);
+    }
+}

package/dist/b2fPortalV3/syncProjectCommons.d.ts

@@ -0,0 +1,8 @@
+type TSyncFilesAndFoldersV2Params = {
+    sourceDirPath: string;
+    targetDirPath: string;
+    fileNamePatterns?: string[];
+    deleteExtraFilesInTarget?: boolean;
+};
+export declare function syncFilesAndFolders({ sourceDirPath, targetDirPath, fileNamePatterns, deleteExtraFilesInTarget, }: TSyncFilesAndFoldersV2Params): Promise<void>;
+export {};

package/dist/b2fPortalV3/syncProjectCommons.js

@@ -0,0 +1,180 @@
+import fs from "node:fs";
+import fsPromises from "node:fs/promises";
+import path from "path";
+import crypto from "node:crypto"; // Added crypto for file hashing
+// Utility function to calculate file hash
+async function getFileHash(filePath) {
+    try {
+        const fileBuffer = await fsPromises.readFile(filePath);
+        const hashSum = crypto.createHash('sha1');
+        hashSum.update(fileBuffer);
+        return hashSum.digest('hex');
+    }
+    catch (error) {
+        console.error(`Error calculating hash for file ${filePath}:`, error);
+        throw new Error(`Failed to calculate file hash: ${error.message}`);
+    }
+}
+export async function syncFilesAndFolders({ sourceDirPath, targetDirPath, fileNamePatterns = [], deleteExtraFilesInTarget = true, }) {
+    // Create target directory if it doesn't exist
+    if (!fs.existsSync(targetDirPath)) {
+        try {
+            await fsPromises.mkdir(targetDirPath, { recursive: true });
+        }
+        catch (error) {
+            console.error(`Error creating target directory ${targetDirPath}:`, error);
+            throw new Error(`Failed to create target directory: ${error.message}`);
+        }
+    } // Load or initialize JSON file to store file details
+    const jsonFilePath = path.join(targetDirPath, "file_details.json");
+    let fileDetails = {};
+    let initialFileDetails = {};
+    if (fs.existsSync(jsonFilePath)) {
+        try {
+            const fileContent = await fsPromises.readFile(jsonFilePath, "utf8");
+            // Handle empty file case
+            if (fileContent.trim() === '') {
+                fileDetails = {};
+            }
+            else {
+                fileDetails = JSON.parse(fileContent);
+            }
+            initialFileDetails = { ...fileDetails };
+        }
+        catch (error) {
+            console.error(`Error reading or parsing ${jsonFilePath}:`, error);
+            // Reset file details if there's an error
+            fileDetails = {};
+            initialFileDetails = {};
+            // Create a valid JSON file
+            await fsPromises.writeFile(jsonFilePath, "{}");
+        }
+    }
+    else {
+        await fsPromises.writeFile(jsonFilePath, "{}");
+    }
+    async function updateFileDetails({ fileName, sourceFilePath, mtime, hash }) {
+        // const stats = await fsPromises.stat(sourceFilePath);
+        fileDetails[fileName] = {
+            sourceFilePath,
+            mtime,
+            localDate: new Date(mtime).toLocaleString(),
+            hash, // Store the hash in file details
+        };
+        if (JSON.stringify(fileDetails) !== JSON.stringify(initialFileDetails)) {
+            try {
+                await fsPromises.writeFile(jsonFilePath, JSON.stringify(fileDetails, null, 2));
+            }
+            catch (error) {
+                console.error(`Error writing to file ${jsonFilePath}:`, error);
+                // Continue execution since this is not critical
+            }
+        }
+    } // Traverse through source directory
+    let filesInSource;
+    try {
+        filesInSource = await fsPromises.readdir(sourceDirPath);
+    }
+    catch (error) {
+        console.error(`Error reading directory ${sourceDirPath}:`, error);
+        throw new Error(`Failed to read source directory: ${error.message}`);
+    }
+    for (const fileName of filesInSource) {
+        const sourcePath = path.join(sourceDirPath, fileName);
+        const targetPath = path.join(targetDirPath, fileName);
+        let stats;
+        try {
+            stats = await fsPromises.lstat(sourcePath);
+        }
+        catch (error) {
+            console.error(`Error getting stats for ${sourcePath}:`, error);
+            continue; // Skip this file/directory and move to next one
+        }
+        if (stats.isDirectory()) {
+            // Recursively sync directories
+            await syncFilesAndFolders({
+                sourceDirPath: sourcePath,
+                targetDirPath: targetPath,
+                fileNamePatterns,
+                deleteExtraFilesInTarget,
+            });
+        }
+        else {
+            // Check if file matches patterns
+            if (fileNamePatterns.length === 0 ||
+                fileNamePatterns.some((pattern) => fileName.includes(pattern))) { // Get source file hash and modified time
+                let sourceStats;
+                let sourceFileModifiedTime;
+                let sourceFileHash;
+                try {
+                    sourceStats = await fsPromises.stat(sourcePath);
+                    sourceFileModifiedTime = sourceStats.mtime.getTime();
+                    sourceFileHash = await getFileHash(sourcePath);
+                }
+                catch (error) {
+                    console.error(`Error getting file information for ${sourcePath}:`, error);
+                    continue; // Skip this file and move to the next one
+                }
+                // Check if file exists in target and if it's modified or new
+                const targetExists = fs.existsSync(targetPath);
+                if (!targetExists ||
+                    !fileDetails[fileName] ||
+                    !fileDetails[fileName]?.hash || // If hash doesn't exist (backwards compatibility)
+                    fileDetails[fileName]?.hash !== sourceFileHash // Primary check: compare file hashes
+                ) { // Copy or replace the file in the target directory
+                    try {
+                        await fsPromises.copyFile(sourcePath, targetPath);
+                        console.log(`Copied file: ${path.relative(sourceDirPath, sourcePath)}`);
+                    }
+                    catch (error) {
+                        console.error(`Error copying file from ${sourcePath} to ${targetPath}:`, error);
+                        // Continue with other files even if one fails
+                    }
+                    // Update file details with hash included
+                    await updateFileDetails({
+                        fileName,
+                        sourceFilePath: sourcePath,
+                        mtime: sourceFileModifiedTime,
+                        hash: sourceFileHash,
+                    });
+                }
+            }
+        }
+    }
+    async function cleanUpFilesAndDirs(fileDetails, targetDir) {
+        // Iterate over fileDetails to check if source paths exist
+        for (const [fileName, detail] of Object.entries(fileDetails)) {
+            const sourceFilePath = detail.sourceFilePath;
+            const targetFilePath = path.join(targetDir, fileName);
+            // Check if the source file exists
+            const sourceExists = fs.existsSync(sourceFilePath);
+            if (!sourceExists) { // Delete the file from the target directory
+                if (fs.existsSync(targetFilePath)) {
+                    try {
+                        await fsPromises.unlink(targetFilePath);
+                        // console.log(`Deleted target file: ${targetFilePath}`);
+                    }
+                    catch (error) {
+                        console.error(`Error deleting file ${targetFilePath}:`, error);
+                        // Continue with other files even if deletion fails
+                    }
+                }
+                // Delete the file entry from fileDetails
+                delete fileDetails[fileName];
+            }
+        }
+        if (JSON.stringify(fileDetails) !== JSON.stringify(initialFileDetails)) {
+            try {
+                await fsPromises.writeFile(jsonFilePath, JSON.stringify(fileDetails, null, 2));
+            }
+            catch (error) {
+                console.error(`Error writing to file ${jsonFilePath} in cleanup:`, error);
+                // Continue execution since this is not critical
+            }
+        }
+    }
+    // Check for files in target directory that are not in source directory
+    if (deleteExtraFilesInTarget) {
+        await cleanUpFilesAndDirs(fileDetails, targetDirPath);
+    }
+}

package/dist/bin/nbk.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "../utils/progress.js";

package/dist/bin/nbk.js

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+import { program } from "commander";
+import { deleteAllRepos } from "../cli/deleteAllRepos.js";
+import { deployAllRepos } from "../cli/deployAllRepos.js";
+import { gitAcpAllRepos } from "../cli/gitAcpAllRepos.js";
+import { gitPushAllRepos } from "../cli/gitPushAllRepos.js";
+import { transfer2Shared } from "../cli/transfer2Shared.js";
+import { initConfig } from "../cli/initConfig.js";
+import { fixConfigFile } from "../cli/fixConfigFile.js";
+import { createInitWorkspaceShellFile } from "../cli/createInitWorkspaceShellFile.js";
+import { addDevVersion } from "../cli/addDevVersion.js";
+import { addProdVersion } from "../cli/addProdVersion.js";
+import "../utils/progress.js";
+import packageJson from "../../package.json" with { type: "json" };
+program
+    .name("nsk")
+    .version(packageJson.version)
+    .description("PrimeXOP Backend Kit - CLI Tool");
+program
+    .command("init")
+    .description("Initialize an empty nsk.config.json file in the project root")
+    .action(async () => {
+    await initConfig();
+});
+program
+    .command("delete-all-repos")
+    .description("Delete b2fPortal directory in all repositories")
+    .action(async () => {
+    await deleteAllRepos();
+});
+program
+    .command("deploy-all-repos")
+    .description("Deploy all repositories")
+    .action(async () => {
+    await deployAllRepos();
+});
+program
+    .command("git-acp-all-repos")
+    .description("Add, commit, and push changes in all repositories")
+    .action(async () => {
+    await gitAcpAllRepos();
+});
+program
+    .command("git-push-all-repos")
+    .description("Push b2fPortal changes in all repositories")
+    .action(async () => {
+    await gitPushAllRepos();
+});
+program
+    .command("fix-config-file")
+    .description("Fix JSON files by adding double quotes to keys and removing trailing commas")
+    .option("-p, --path <path>", "Path to the JSON file to fix (defaults to nsk.config.json)")
+    .action(async (options) => {
+    await fixConfigFile(options.path);
+});
+program
+    .command("transfer-2-shared")
+    .description("Transfer project files to shared backend repositories")
+    .action(async () => {
+    await transfer2Shared();
+});
+program
+    .command("create-init-workspace-shell-file")
+    .description("Create a shell script to initialize and open project workspaces")
+    .action(async () => {
+    await createInitWorkspaceShellFile();
+});
+program
+    .command("add-dev-version")
+    .description("Update package.json to use local development version of @digicroz/node-server-kit and run npm install")
+    .option("-d, --dir <directory>", "Target directory containing package.json (defaults to current directory)")
+    .action(async (options) => {
+    await addDevVersion(options.dir);
+});
+program
+    .command("add-prod-version")
+    .description("Update package.json to use published version of @digicroz/node-server-kit and run npm install")
+    .option("-d, --dir <directory>", "Target directory containing package.json (defaults to current directory)")
+    .option("-v, --version <version>", "Specific version to use (defaults to latest)")
+    .action(async (options) => {
+    await addProdVersion(options.dir, options.version);
+});
+program.parseAsync(process.argv);

package/dist/cli/addDevVersion.d.ts

@@ -0,0 +1 @@
+export declare function addDevVersion(targetDir?: string): Promise<void>;

package/dist/cli/addDevVersion.js

@@ -0,0 +1,51 @@
+import fs from "fs";
+import path from "path";
+import { execSync } from "child_process";
+export async function addDevVersion(targetDir) {
+    try {
+        // Use current directory if no target directory provided
+        const targetDirectory = targetDir || process.cwd();
+        const packageJsonPath = path.join(targetDirectory, "package.json");
+        // Check if package.json exists
+        if (!fs.existsSync(packageJsonPath)) {
+            console.error(`No package.json found in ${targetDirectory}`);
+            return;
+        }
+        console.log(`Updating package.json in ${targetDirectory}`);
+        // Read the package.json file
+        const packageJsonContent = fs.readFileSync(packageJsonPath, "utf-8");
+        const packageJson = JSON.parse(packageJsonContent);
+        // Update or add the dependency
+        const nskPath = "file:C:/primexopRepos/nsk";
+        const originalVersion = packageJson.dependencies?.["@digicroz/node-server-kit"] ||
+            packageJson.devDependencies?.["@digicroz/node-server-kit"];
+        // Determine if it's in dependencies or devDependencies
+        let dependencyType = "dependencies";
+        if (!packageJson.dependencies?.["@digicroz/node-server-kit"] &&
+            packageJson.devDependencies?.["@digicroz/node-server-kit"]) {
+            dependencyType = "devDependencies";
+        }
+        // Create the section if it doesn't exist
+        if (!packageJson[dependencyType]) {
+            packageJson[dependencyType] = {};
+        }
+        // Update the dependency
+        packageJson[dependencyType]["@digicroz/node-server-kit"] = nskPath;
+        // Save the updated package.json
+        fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+        console.log(`Updated @digicroz/node-server-kit to use local version: ${nskPath}`);
+        if (originalVersion) {
+            console.log(`Original version was: ${originalVersion}`);
+        }
+        // Run npm install
+        console.log("Running npm install...");
+        execSync("npm install", {
+            stdio: "inherit",
+            cwd: targetDirectory,
+        });
+        console.log("Successfully installed the local development version of @digicroz/node-server-kit");
+    }
+    catch (error) {
+        console.error("Error adding dev version:", error);
+    }
+}

package/dist/cli/addProdVersion.d.ts

@@ -0,0 +1 @@
+export declare function addProdVersion(targetDir?: string, version?: string): Promise<void>;

package/dist/cli/addProdVersion.js

@@ -0,0 +1,70 @@
+import fs from "fs";
+import path from "path";
+import { execSync } from "child_process";
+export async function addProdVersion(targetDir, version) {
+    try {
+        // Use current directory if no target directory provided
+        const targetDirectory = targetDir || process.cwd();
+        const packageJsonPath = path.join(targetDirectory, "package.json");
+        // Check if package.json exists
+        if (!fs.existsSync(packageJsonPath)) {
+            console.error(`No package.json found in ${targetDirectory}`);
+            return;
+        }
+        console.log(`Updating package.json in ${targetDirectory}`);
+        // Read the package.json file
+        const packageJsonContent = fs.readFileSync(packageJsonPath, "utf-8");
+        const packageJson = JSON.parse(packageJsonContent);
+        // Determine the target version to use
+        const prodVersion = version || "latest";
+        // Check if package is in dependencies or devDependencies
+        let dependencyType = null;
+        let originalVersion = null;
+        if (packageJson.dependencies?.["@digicroz/node-server-kit"]) {
+            dependencyType = "dependencies";
+            originalVersion = packageJson.dependencies["@digicroz/node-server-kit"];
+        }
+        else if (packageJson.devDependencies?.["@digicroz/node-server-kit"]) {
+            dependencyType = "devDependencies";
+            originalVersion = packageJson.devDependencies["@digicroz/node-server-kit"];
+        }
+        if (!dependencyType) {
+            console.log("@digicroz/node-server-kit not found in dependencies or devDependencies. Will add to dependencies.");
+            dependencyType = "dependencies";
+            if (!packageJson[dependencyType]) {
+                packageJson[dependencyType] = {};
+            }
+        }
+        // Get the latest version from npm if 'latest' is specified
+        let versionToUse = prodVersion;
+        if (prodVersion === "latest") {
+            try {
+                const npmViewResult = execSync("npm view @digicroz/node-server-kit version", { encoding: "utf-8" }).trim();
+                versionToUse = `^${npmViewResult}`;
+                console.log(`Latest npm version found: ${npmViewResult}`);
+            }
+            catch (err) {
+                console.warn('Failed to get latest version from npm. Using "latest" tag instead.');
+                versionToUse = "latest";
+            }
+        }
+        // Update the dependency
+        packageJson[dependencyType]["@digicroz/node-server-kit"] = versionToUse;
+        // Save the updated package.json
+        fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+        console.log(`Updated @digicroz/node-server-kit to use production version: ${versionToUse}`);
+        if (originalVersion) {
+            console.log(`Original version was: ${originalVersion}`);
+        }
+        // Run npm install
+        console.log("Running npm install...");
+        execSync("npm install", {
+            stdio: "inherit",
+            cwd: targetDirectory,
+        });
+        console.log("Successfully installed the production version of @digicroz/node-server-kit");
+    }
+    catch (error) {
+        console.error("Error adding production version:", error);
+    }
+}

package/dist/cli/createInitWorkspaceShellFile.d.ts

@@ -0,0 +1 @@
+export declare function createInitWorkspaceShellFile(): Promise<void>;

package/dist/cli/createInitWorkspaceShellFile.js

@@ -0,0 +1,129 @@
+import fs from "fs";
+import path from "path";
+import { clientRootDirPath } from "../utils/path.js";
+import { loadConfig } from "../utils/loadConfig.js";
+export async function createInitWorkspaceShellFile() {
+    try {
+        // Load configuration
+        const configPath = path.join(clientRootDirPath, "nsk.config.json");
+        const config = loadConfig(configPath);
+        if (!config) {
+            console.error("Configuration file not found or invalid");
+            return;
+        }
+        // Create shell script content with escaped bash variables using $ prefix
+        let shellScriptContent = `#!/usr/bin/bash
+
+current_path=\$(pwd)
+echo "Current path is: \$current_path"
+
+# Function to select editor
+select_editor() {
+    # Default editor
+    EDITOR="code"
+    
+    # Array of options
+    options=("VSCode" "Cursor" "Trae")
+    selected=0
+    
+    # Function to print menu
+    print_menu() {
+        for i in "\${!options[@]}"; do
+            if [ \$i -eq \$selected ]; then
+                echo "> \${options[\$i]}"
+            else
+                echo "  \${options[\$i]}"
+            fi
+        done
+    }
+    
+    # Print initial menu
+    echo "Select editor (default: VSCode in 10 seconds):"
+    print_menu
+    
+    # Start timer in background
+    (sleep 10; kill -USR1 \$$) & timer_pid=\$!
+    
+    # Handle timer expiration
+    trap 'selected=0; break' USR1
+    
+    # Read keys
+    while true; do
+        read -rsn1 key
+        case "\$key" in
+            A) # Up arrow
+                ((selected--))
+                [ \$selected -lt 0 ] && selected=\$((\${#options[@]}-1))
+                clear
+                echo "Select editor (default: VSCode in 10 seconds):"
+                print_menu
+                ;;
+            B) # Down arrow
+                ((selected++))
+                [ \$selected -ge \${#options[@]} ] && selected=0
+                clear
+                echo "Select editor (default: VSCode in 10 seconds):"
+                print_menu
+                ;;
+            "") # Enter key
+                kill \$timer_pid 2>/dev/null
+                break
+                ;;
+        esac
+    done
+    
+    # Kill timer if it's still running
+    kill \$timer_pid 2>/dev/null
+    
+    # Set editor based on selection
+    if [ \$selected -eq 1 ]; then
+        EDITOR="cursor"
+    elif [ \$selected -eq 2 ]; then
+        EDITOR="trae"
+    fi
+    
+    echo "Selected: \${options[\$selected]}"
+    return \$selected
+}
+
+# Call select editor function
+select_editor
+EDITOR_CHOICE=\$?
+
+# Store the editor command
+if [[ \$EDITOR_CHOICE -eq 1 ]]; then
+    EDITOR_CMD="cursor"
+elif [[ \$EDITOR_CHOICE -eq 2 ]]; then
+    EDITOR_CMD="trae"
+else
+    EDITOR_CMD="code"
+fi
+
+echo "Editor command: \$EDITOR_CMD"
+
+`;
+        // Add project paths from configuration
+        for (const project of config.projects) {
+            shellScriptContent += `\n# Project: ${project.projectName}\n`;
+            shellScriptContent += `cd ${project.projectBaseDirPath}\n`;
+            shellScriptContent += `\$EDITOR_CMD .\n`;
+            // Add sections if they have repository paths
+            for (const section of project.sections) {
+                if (section.repository && section.repository.path) {
+                    shellScriptContent += `\ncd ${section.repository.path}\n`;
+                    shellScriptContent += `\$EDITOR_CMD .\n`;
+                }
+            }
+            // Return to original directory after each project
+            shellScriptContent += `\ncd \$current_path\n`;
+        }
+        // Save shell script to file
+        const shellScriptPath = path.join(clientRootDirPath, "initWorkspace.sh");
+        fs.writeFileSync(shellScriptPath, shellScriptContent, { mode: 0o755 }); // Set execute permissions
+        console.log(`Shell script created at: ${shellScriptPath}`);
+        console.log("Remember to make it executable with: chmod +x initWorkspace.sh");
+    }
+    catch (error) {
+        console.error("Error creating workspace init shell file:", error);
+    }
+}

package/dist/cli/deleteAllRepos.d.ts

@@ -0,0 +1 @@
+export declare function deleteAllRepos(): Promise<void>;