adminforth 1.18.0 → 1.20.0

package/commands/createCustomComponent/configUpdater.js

@@ -0,0 +1,207 @@
+import fs from 'fs/promises';
+import path from 'path';
+import chalk from 'chalk';
+import recast from 'recast'; // Import recast
+import * as typescriptParser from 'recast/parsers/typescript.js'; // Import the parser using ESM and include the .js extension
+
+const b = recast.types.builders; // Like t.* in babel/types
+const n = recast.types.namedTypes; // Like t.is* in babel/types
+
+
+async function findResourceFilePath(resourceId) {
+    const projectRoot = process.cwd();
+    const resourcesDir = path.resolve(projectRoot, 'resources');
+    console.log(chalk.dim(`Scanning for resource files in: ${resourcesDir}`));
+
+    let tsFiles = [];
+    try {
+        const entries = await fs.readdir(resourcesDir, { withFileTypes: true });
+        tsFiles = entries
+            .filter(dirent => dirent.isFile() && dirent.name.endsWith('.ts') && !dirent.name.endsWith('.d.ts'))
+            .map(dirent => dirent.name);
+    } catch (error) {
+        if (error.code === 'ENOENT') {
+            throw new Error(`Resources directory not found at ${resourcesDir}. Please ensure it exists.`);
+        }
+        throw new Error(`Failed to read resources directory ${resourcesDir}: ${error.message}`);
+    }
+
+    console.log(chalk.dim(`Found .ts files to scan: ${tsFiles.join(', ') || 'None'}`));
+
+    for (const file of tsFiles) {
+        const filePath = path.resolve(resourcesDir, file);
+        console.log(chalk.dim(`Attempting to process file: ${file}`));
+        try {
+            const content = await fs.readFile(filePath, 'utf-8');
+            const ast = recast.parse(content, {
+                parser: typescriptParser 
+            });
+
+            let foundResourceId = null;
+
+            recast.visit(ast, {
+                visitExportDefaultDeclaration(path) {
+                    if (foundResourceId !== null) return false; // Stop visiting deeper if already found
+
+                    const declaration = path.node.declaration;
+                    let objectExpressionNode = null;
+
+                    if (n.TSAsExpression.check(declaration) && n.ObjectExpression.check(declaration.expression)) {
+                        objectExpressionNode = declaration.expression;
+                    }
+                    else if (n.ObjectExpression.check(declaration)) {
+                        objectExpressionNode = declaration;
+                    }
+
+                    if (objectExpressionNode) {
+                        const resourceIdProp = objectExpressionNode.properties.find(prop =>
+                            n.ObjectProperty.check(prop) &&
+                            n.Identifier.check(prop.key) &&
+                            prop.key.name === 'resourceId' &&
+                            n.StringLiteral.check(prop.value)
+                        );
+                        if (resourceIdProp) {
+                            foundResourceId = resourceIdProp.value.value; // Get the string value
+                            console.log(chalk.dim(`  Extracted resourceId '${foundResourceId}' from ${file}`));
+                            this.abort(); // Stop traversal for this file once found
+                        }
+                    }
+                    return false;
+                }
+            });
+
+            console.log(chalk.dim(`  Finished processing ${file}. Found resourceId: ${foundResourceId || 'null'}`));
+
+            if (foundResourceId === resourceId) {
+                console.log(chalk.dim(`  Match found! Returning path: ${filePath}`));
+                return filePath;
+            }
+        } catch (parseError) {
+            if (parseError.message.includes('require is not defined')) {
+                 console.error(chalk.red(`❌ Internal Error: Failed to load Recast parser in ESM context for ${file}.`));
+             } else {
+                console.warn(chalk.yellow(`⚠️ Warning: Could not process file ${file}. Skipping. Error: ${parseError.message}`));
+             }
+        }
+    }
+
+    throw new Error(`Could not find a resource file in '${resourcesDir}' with resourceId: '${resourceId}'`);
+}
+
+
+export async function updateResourceConfig(resourceId, columnName, fieldType, componentPathForConfig) {
+    const filePath = await findResourceFilePath(resourceId);
+    console.log(chalk.dim(`Attempting to update resource config: ${filePath}`));
+
+    let content;
+    try {
+        content = await fs.readFile(filePath, 'utf-8');
+    } catch (error) {
+        console.error(chalk.red(`❌ Error reading resource file: ${filePath}`));
+        console.error(error);
+        throw new Error(`Could not read resource file ${filePath}.`);
+    }
+
+    try {
+        const ast = recast.parse(content, {
+            parser: typescriptParser 
+        });
+
+        let updateApplied = false;
+
+        recast.visit(ast, {
+            visitExportDefaultDeclaration(path) {
+                const declaration = path.node.declaration;
+                let objectExpressionNode = null;
+
+                if (n.TSAsExpression.check(declaration) && n.ObjectExpression.check(declaration.expression)) {
+                    objectExpressionNode = declaration.expression;
+                } else if (n.ObjectExpression.check(declaration)) {
+                    objectExpressionNode = declaration;
+                }
+
+                if (!objectExpressionNode) {
+                    console.warn(chalk.yellow(`Warning: Default export in ${filePath} is not a recognized ObjectExpression or TSAsExpression containing one. Skipping update.`));
+                    return false;
+                }
+
+                const properties = objectExpressionNode.properties;
+                const columnsProperty = properties.find(prop =>
+                    n.ObjectProperty.check(prop) && n.Identifier.check(prop.key) && prop.key.name === 'columns'
+                );
+
+                if (!columnsProperty || !n.ArrayExpression.check(columnsProperty.value)) {
+                    console.warn(chalk.yellow(`Warning: Could not find 'columns' array in the default export of ${filePath}. Skipping update.`));
+                    return false;
+                }
+
+                const columnsArray = columnsProperty.value.elements;
+                const targetColumn = columnsArray.find(col => {
+                    if (n.ObjectExpression.check(col)) {
+                        const nameProp = col.properties.find(p =>
+                            n.ObjectProperty.check(p) && n.Identifier.check(p.key) && p.key.name === 'name' &&
+                            n.StringLiteral.check(p.value) && p.value.value === columnName
+                        );
+                        return !!nameProp;
+                    }
+                    return false;
+                });
+
+                if (!targetColumn || !n.ObjectExpression.check(targetColumn)) {
+                    return false;
+                }
+
+                let componentsProperty = targetColumn.properties.find(p =>
+                    n.ObjectProperty.check(p) && n.Identifier.check(p.key) && p.key.name === 'components'
+                );
+
+                if (!componentsProperty) {
+                    const newComponentsObject = b.objectExpression([]);
+                    componentsProperty = b.objectProperty(b.identifier('components'), newComponentsObject);
+
+                    const nameIndex = targetColumn.properties.findIndex(p => n.ObjectProperty.check(p) && n.Identifier.check(p.key) && p.key.name === 'name');
+                    targetColumn.properties.splice(nameIndex !== -1 ? nameIndex + 1 : targetColumn.properties.length, 0, componentsProperty);
+                    console.log(chalk.dim(`Added 'components' object to column '${columnName}'.`));
+
+                } else if (!n.ObjectExpression.check(componentsProperty.value)) {
+                    console.warn(chalk.yellow(`Warning: 'components' property in column '${columnName}' is not an object. Skipping update.`));
+                    return false;
+                }
+
+                const componentsObject = componentsProperty.value;
+                let fieldTypeProperty = componentsObject.properties.find(p =>
+                    n.ObjectProperty.check(p) && n.Identifier.check(p.key) && p.key.name === fieldType
+                );
+
+                const newComponentValue = b.stringLiteral(componentPathForConfig);
+
+                if (fieldTypeProperty) {
+                    fieldTypeProperty.value = newComponentValue;
+                    console.log(chalk.dim(`Updated '${fieldType}' component path in column '${columnName}'.`));
+                } else {
+                    fieldTypeProperty = b.objectProperty(b.identifier(fieldType), newComponentValue);
+                    componentsObject.properties.push(fieldTypeProperty);
+                    console.log(chalk.dim(`Added '${fieldType}' component path to column '${columnName}'.`));
+                }
+
+                updateApplied = true;
+                this.abort();
+                return false;
+            }
+        });
+
+        if (!updateApplied) {
+             throw new Error(`Could not find column '${columnName}' or apply update within the default export's 'columns' array in ${filePath}.`);
+        }
+
+        const outputCode = recast.print(ast).code;
+
+        await fs.writeFile(filePath, outputCode, 'utf-8');
+        console.log(chalk.dim(`Successfully updated resource configuration file (preserving formatting): ${filePath}`));
+
+    } catch (error) {
+        console.error(chalk.red(`❌ Error processing resource file: ${filePath}`));
+        console.error(error);
+        throw new Error(`Failed to update resource file ${path.basename(filePath)}: ${error.message}`);
+    }
+}

package/commands/createCustomComponent/fileGenerator.js

@@ -0,0 +1,72 @@
+import fs from 'fs/promises';
+import path from 'path';
+import chalk from 'chalk';
+import Handlebars from 'handlebars';
+import { fileURLToPath } from 'url';
+
+async function renderHBSTemplate(templatePath, data) {
+  try {
+    const templateContent = await fs.readFile(templatePath, 'utf-8');
+    const compiled = Handlebars.compile(templateContent);
+    return compiled(data);
+  } catch (error) {
+    console.error(chalk.red(`❌ Error reading or compiling template: ${templatePath}`));
+    throw error;
+  }
+}
+
+async function generateVueContent(fieldType, { resource, column }) {
+  const componentName = `${resource.label}${column.label}${fieldType.charAt(0).toUpperCase() + fieldType.slice(1)}`;
+  const columnName = column.name;
+  const resourceId = resource.resourceId;
+
+  const __filename = fileURLToPath(import.meta.url);
+  const __dirname = path.dirname(__filename);
+  const templatePath = path.join(__dirname, 'templates', 'customFields', `${fieldType}.vue.hbs`);
+
+  console.log(chalk.dim(`Using template: ${templatePath}`));
+
+  const context = {
+    componentName,
+    columnName,
+    resourceId,
+    resource,
+    column
+  };
+
+  try {
+    const fileContent = await renderHBSTemplate(templatePath, context);
+    return fileContent;
+  } catch (error) {
+    console.error(chalk.red(`❌ Failed to generate content for ${componentName}.vue`));
+    throw error;
+  }
+}
+
+export async function generateComponentFile(componentFileName, fieldType, context, config) {
+
+  const customDirRelative = 'custom';
+
+  const projectRoot = process.cwd();
+  const customDirPath = path.resolve(projectRoot, customDirRelative);
+  const absoluteComponentPath = path.resolve(customDirPath, componentFileName);
+
+  try {
+    await fs.mkdir(customDirPath, { recursive: true });
+    console.log(chalk.dim(`Ensured custom directory exists: ${customDirPath}`));
+
+    const fileContent = await generateVueContent(fieldType, context);
+
+    await fs.writeFile(absoluteComponentPath, fileContent, 'utf-8');
+    console.log(chalk.green(`✅ Generated component file: ${absoluteComponentPath}`));
+
+    return absoluteComponentPath;
+
+  } catch (error) {
+    console.error(chalk.red(`❌ Error creating component file at ${absoluteComponentPath}:`));
+    if (!error.message.includes('template')) {
+       console.error(error);
+    }
+    throw error;
+  }
+}

package/commands/createCustomComponent/main.js

@@ -0,0 +1,138 @@
+import { select, confirm, Separator } from '@inquirer/prompts';
+import chalk from 'chalk';
+import path from 'path'; // Import path
+import { loadAdminForthConfig } from './configLoader.js'; // Helper to load config
+import { generateComponentFile } from './fileGenerator.js'; // Helper to create the .vue file
+import { updateResourceConfig } from './configUpdater.js'; // Helper to modify resource .ts file
+// import { openFileInIde } from './ideHelper.js'; // Helper to open file
+
+export default async function createComponent(args) {
+  console.log('This command will help you to generate boilerplate for component.\n');
+
+  const config = await loadAdminForthConfig();
+  const resources = config.resources; 
+
+  const componentType = await select({
+    message: 'What component type would you like to add?',
+    choices: [
+      { name: `🔤 Custom fields ${chalk.grey('fields')}`, value: 'fields' },
+      { name: `➖ CRUD page injections ${chalk.grey('crudPage')}`, value: 'crudPage' },
+      { name: `🔐 Login page injections ${chalk.grey('login')}`, value: 'login' },
+      { name: `🌐 Global Injections ${chalk.grey('global')}`, value: 'global' },
+    ],
+  });
+
+  if (componentType === 'fields') {
+    await handleFieldComponentCreation(config, resources);
+  } else if (componentType === 'crudPage') {
+    await handleCrudPageInjectionCreation(config, resources);
+  } else if (componentType === 'login') {
+    await handleLoginPageInjectionCreation(config);
+  } else if (componentType === 'global') {
+    await handleGlobalInjectionCreation(config);
+  }
+}
+
+async function handleFieldComponentCreation(config, resources) {
+  console.log(chalk.grey('Selected ❯ 🔤 Custom fields'));
+
+  const fieldType = await select({
+      message: 'What view component would you like to add?',
+      choices: [
+          { name: '🔸 list', value: 'list' },
+          { name: '📃 show', value: 'show' },
+          { name: '✏️ edit', value: 'edit' },
+          { name: '➕ create', value: 'create' },
+          new Separator(),
+          { name: '🔙 BACK', value: '__BACK__' },
+      ]
+  });
+  if (fieldType === '__BACK__') return createComponent([]); // Go back to main menu
+
+  console.log(chalk.grey(`Selected ❯ 🔤 Custom fields ❯ ${fieldType}`));
+
+  const resourceId = await select({
+      message: 'Select resource for which you want to change component:',
+      choices: [
+          ...resources.map(r => ({ name: `${r.label} ${chalk.grey(`${r.resourceId}`)}`, value: r.resourceId })),
+          new Separator(),
+          { name: '🔙 BACK', value: '__BACK__' },
+      ]
+  });
+   if (resourceId === '__BACK__') return handleFieldComponentCreation(config, resources); // Pass config back
+
+  const selectedResource = resources.find(r => r.resourceId === resourceId);
+  console.log(chalk.grey(`Selected ❯ 🔤 Custom fields ❯ ${fieldType} ❯ ${selectedResource.label}`));
+
+  const columnName = await select({
+      message: 'Select column for which you want to create component:',
+      choices: [
+          ...selectedResource.columns.map(c => ({ name: `${c.label} ${chalk.grey(`${c.name}`)}`, value: c.name })),
+          new Separator(),
+          { name: '🔙 BACK', value: '__BACK__' },
+      ]
+  });
+  if (columnName === '__BACK__') return handleFieldComponentCreation(config, resources); // Pass config back
+
+  const selectedColumn = selectedResource.columns.find(c => c.name === columnName);
+   console.log(chalk.grey(`Selected ❯ 🔤 Custom fields ❯ ${fieldType} ❯ ${selectedResource.label} ❯ ${selectedColumn.label}`));
+   console.log(chalk.dim(`One-line alternative: |adminforth component fields.${fieldType}.${resourceId}.${columnName}|`));
+
+
+  const existingComponentPath = null;
+
+  if (existingComponentPath) {
+    const action = await select({
+        message: 'You already have a component for this field, open it in editor?',
+        choices: [
+            { name: '✏️ Open in IDE', value: 'open' },
+            { name: '🔙 BACK', value: '__BACK__' },
+            { name: '🚪 Exit', value: '__EXIT__' },
+        ]
+    });
+    if (action === 'open') {
+        // await openFileInIde(existingComponentPath); // Needs absolute path
+        console.log(`Opening ${existingComponentPath}... (Implementation needed)`);
+    } else if (action === '__BACK__') {
+        return handleFieldComponentCreation(config, resources); // Pass config back
+    } else {
+        process.exit(0);
+    }
+  } else {
+    const safeResourceLabel = selectedResource.label.replace(/[^a-zA-Z0-9]/g, '');
+    const safeColumnLabel = selectedColumn.label.replace(/[^a-zA-Z0-9]/g, '');
+    const componentFileName = `${safeResourceLabel}${safeColumnLabel}${fieldType.charAt(0).toUpperCase() + fieldType.slice(1)}.vue`; // e.g., UserEmailShow.vue
+    const componentPathForConfig = `@@/${componentFileName}`; // Path relative to custom dir for config
+
+    let absoluteComponentPath;
+    try {
+        absoluteComponentPath = await generateComponentFile(
+            componentFileName,
+            fieldType,
+            { resource: selectedResource, column: selectedColumn },
+            config
+        );
+        console.log(chalk.dim(`Component generation successful: ${absoluteComponentPath}`));
+
+        await updateResourceConfig(selectedResource.resourceId, columnName, fieldType, componentPathForConfig);
+        console.log(chalk.green(`\n✅ Successfully created component ${componentPathForConfig} and updated configuration.`));
+
+        const openNow = await confirm({
+            message: 'Open the new component file in your IDE?',
+            default: true
+        });
+        if (openNow) {  // await openFileInIde(absoluteComponentPath); // Use the absolute path here
+           console.log(`Opening ${absoluteComponentPath}... (Implementation needed)`);
+        }
+
+    } catch (error) {
+        console.error(chalk.red('\n❌ Component creation failed. Please check the errors above.'));
+        process.exit(1);
+    }
+  }
+}
+
+// --- TODO: Implement similar handlers for other component types (pass config) ---
+async function handleCrudPageInjectionCreation(config, resources) { console.log('CRUD Page Injection creation not implemented yet.'); }
+async function handleLoginPageInjectionCreation(config) { console.log('Login Page Injection creation not implemented yet.'); }
+async function handleGlobalInjectionCreation(config) { console.log('Global Injection creation not implemented yet.'); }

package/commands/createCustomComponent/templates/customFields/create.vue.hbs

@@ -0,0 +1,41 @@
+<template>
+  <Select
+      class="w-full"
+      :options="column.enum"
+      :model-value="record[column.name]"
+      @update:model-value="emit('update:value', $event)"
+  >
+    <template #item="{option}">
+      <span class="text-xl inline-flex">\{{ getCountryFlag(option.value) }}</span> \{{ option.label }}
+    </template>
+
+    <template #selected-item="{option}">
+      <span class="text-xl inline-flex">\{{ getCountryFlag(option.value) }}</span> \{{ option.label }}
+    </template>
+  </Select>
+</template>
+
+<script setup lang="ts">
+import Select from "@/afcl/Select.vue";
+import type {
+  AdminForthResourceColumnCommon,
+  AdminForthResourceCommon,
+  AdminUser,
+} from "@/types/Common";
+
+const props = defineProps<{
+  column: AdminForthResourceColumnCommon;
+  record: any;
+  meta: any;
+  resource: AdminForthResourceCommon;
+  adminUser: AdminUser;
+}>();
+
+const emit = defineEmits(["update:value"]);
+
+function getCountryFlag(countryCode: string) {
+  return countryCode?.toUpperCase()
+    .replace(/./g, (char) => String.fromCodePoint(char.charCodeAt(0) + 127397));
+}
+
+</script>

package/commands/createCustomComponent/templates/customFields/edit.vue.hbs

@@ -0,0 +1,41 @@
+<template>
+  <Select
+      class="w-full"
+      :options="column.enum"
+      :model-value="record[column.name]"
+      @update:model-value="emit('update:value', $event)"
+  >
+    <template #item="{option}">
+      <span class="text-xl inline-flex">\{{ getCountryFlag(option.value) }}</span> \{{ option.label }}
+    </template>
+
+    <template #selected-item="{option}">
+      <span class="text-xl inline-flex">\{{ getCountryFlag(option.value) }}</span> \{{ option.label }}
+    </template>
+  </Select>
+</template>
+
+<script setup lang="ts">
+import Select from "@/afcl/Select.vue";
+import type {
+  AdminForthResourceColumnCommon,
+  AdminForthResourceCommon,
+  AdminUser,
+} from "@/types/Common";
+
+const props = defineProps<{
+  column: AdminForthResourceColumnCommon;
+  record: any;
+  meta: any;
+  resource: AdminForthResourceCommon;
+  adminUser: AdminUser;
+}>();
+
+const emit = defineEmits(["update:value"]);
+
+function getCountryFlag(countryCode: string) {
+  return countryCode?.toUpperCase()
+    .replace(/./g, (char) => String.fromCodePoint(char.charCodeAt(0) + 127397));
+}
+
+</script>

package/commands/createCustomComponent/templates/customFields/list.vue.hbs

@@ -0,0 +1,18 @@
+<template>
+    <div v-if='record[column.name]'
+        class="text-red-500"
+    >\{{ record[column.name] }}</div>
+</template> 
+
+<script setup>
+
+    defineProps({
+    record: Object,
+    resource: Object,
+    adminUser: Object,
+    meta: Object,
+    column: Object
+    });
+
+</script>
+

package/commands/createCustomComponent/templates/customFields/show.vue.hbs

@@ -0,0 +1,17 @@
+<template>
+    <div v-if='record[column.name]'
+        class="text-red-500"
+    >\{{ record[column.name] }}</div>
+</template> 
+
+<script setup>
+
+    defineProps({
+    record: Object,
+    resource: Object,
+    adminUser: Object,
+    meta: Object,
+    column: Object
+    });
+
+</script>

package/commands/proxy.ts

@@ -0,0 +1,60 @@
+// tsproxy.ts
+import { writeFile, unlink } from 'fs/promises';
+import { randomUUID } from 'crypto';
+import { pathToFileURL } from 'url';
+import path from 'path';
+
+(async () => {
+  const chunks: Buffer[] = [];
+
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+
+  const code = Buffer.concat(chunks).toString();
+
+  const tmpFileName = `.tmp-tsproxy-${randomUUID()}.ts`;
+  
+  const tmpFile = path.join(process.cwd(), tmpFileName);
+
+  const origLog = console.log;
+  let capturedLogs: any[] = [];
+  console.log = (...args: any[]) => {
+    capturedLogs.push(args);
+  }
+
+  process.env.HEAVY_DEBUG && console.log(`🪲 TMP proxy file: ${tmpFile}`);
+  process.env.HEAVY_DEBUG && console.log(`🪲 Current working directory: ${process.cwd()}`);
+  
+  try {
+    // Save code to a temp file
+    await writeFile(tmpFile, code);
+
+    // Dynamically import the file
+    const module = await import(pathToFileURL(tmpFile).href);
+
+    if (typeof module.exec !== 'function') {
+      throw new Error("Module does not export an 'exec' function");
+    }
+
+    const result = await Promise.resolve(module.exec());
+
+    // Restore original console.log
+    console.log = origLog;
+    console.log(JSON.stringify({ 
+      result, 
+      capturedLogs,
+      error: null 
+    }));
+  } catch (error: any) {
+    // Restore original console.log
+    console.log = origLog;
+    console.log(JSON.stringify({ 
+      error: error.message, 
+      stack: error.stack,
+      capturedLogs 
+    }));
+  } finally {
+    await unlink(tmpFile).catch(() => {});
+  }
+})();

package/dist/commands/proxy.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=proxy.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"proxy.d.ts","sourceRoot":"","sources":["../../commands/proxy.ts"],"names":[],"mappings":""}

package/dist/commands/proxy.js

@@ -0,0 +1,71 @@
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+// tsproxy.ts
+import { writeFile, unlink } from 'fs/promises';
+import { randomUUID } from 'crypto';
+import { pathToFileURL } from 'url';
+import path from 'path';
+(async () => {
+    var _a, e_1, _b, _c;
+    const chunks = [];
+    try {
+        for (var _d = true, _e = __asyncValues(process.stdin), _f; _f = await _e.next(), _a = _f.done, !_a; _d = true) {
+            _c = _f.value;
+            _d = false;
+            const chunk = _c;
+            chunks.push(chunk);
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (!_d && !_a && (_b = _e.return)) await _b.call(_e);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    const code = Buffer.concat(chunks).toString();
+    const tmpFileName = `.tmp-tsproxy-${randomUUID()}.ts`;
+    const tmpFile = path.join(process.cwd(), tmpFileName);
+    const origLog = console.log;
+    let capturedLogs = [];
+    console.log = (...args) => {
+        capturedLogs.push(args);
+    };
+    process.env.HEAVY_DEBUG && console.log(`🪲 TMP proxy file: ${tmpFile}`);
+    process.env.HEAVY_DEBUG && console.log(`🪲 Current working directory: ${process.cwd()}`);
+    try {
+        // Save code to a temp file
+        await writeFile(tmpFile, code);
+        // Dynamically import the file
+        const module = await import(pathToFileURL(tmpFile).href);
+        if (typeof module.exec !== 'function') {
+            throw new Error("Module does not export an 'exec' function");
+        }
+        const result = await Promise.resolve(module.exec());
+        // Restore original console.log
+        console.log = origLog;
+        console.log(JSON.stringify({
+            result,
+            capturedLogs,
+            error: null
+        }));
+    }
+    catch (error) {
+        // Restore original console.log
+        console.log = origLog;
+        console.log(JSON.stringify({
+            error: error.message,
+            stack: error.stack,
+            capturedLogs
+        }));
+    }
+    finally {
+        await unlink(tmpFile).catch(() => { });
+    }
+})();
+//# sourceMappingURL=proxy.js.map