@intrig/core 0.0.15-23 → 0.0.15-25

package/main.js

@@ -81,6 +81,8 @@ var src = __webpack_require__(1);
 var common = __webpack_require__(3);
 // EXTERNAL MODULE: ../../node_modules/cross-spawn/index.js
 var cross_spawn = __webpack_require__(1309);
+// EXTERNAL MODULE: external "child_process"
+var external_child_process_ = __webpack_require__(1020);
 // EXTERNAL MODULE: ../../node_modules/@nestjs/config/index.js
 var config = __webpack_require__(1322);
 // EXTERNAL MODULE: external "fs"
@@ -251,6 +253,7 @@ function process_manager_service_ts_metadata(k, v) {
 
 
 
+
 class ProcessManagerService {
     constructor(discovery, config){
         this.discovery = discovery;
@@ -272,6 +275,28 @@ class ProcessManagerService {
         child.unref();
         this.logger.log(`Spawned daemon (pid=${child.pid})`);
     }
+    /**
+   * Start the daemon in foreground mode with verbose logging.
+   * This blocks until the process exits or is interrupted.
+   */ async startForeground() {
+        if (await this.discovery.isRunning()) {
+            this.logger.log('Daemon already running (via discovery)');
+            return;
+        }
+        const result = (0,external_child_process_.spawnSync)('intrig', [
+            "run"
+        ], {
+            stdio: 'inherit',
+            cwd: this.config.get('rootDir') ?? process.cwd()
+        });
+        if (result.error) {
+            this.logger.error('Failed to start daemon:', result.error);
+            throw result.error;
+        }
+        if (result.status !== 0) {
+            this.logger.error(`Daemon exited with code ${result.status}`);
+        }
+    }
     async stop() {
         const meta = this.discovery.getMetadata();
         if (!meta) {
@@ -334,17 +359,35 @@ class UpSubCommand extends src.CommandRunner {
     constructor(pm){
         super(), this.pm = pm;
     }
-    async run() {
+    parseVerbose() {
+        return true;
+    }
+    async run(passedParams, options) {
         const isRunning = await this.pm.isRunning();
         if (isRunning) {
             console.log('✓ Daemon is already running');
             return;
         }
-        console.log('Starting daemon...');
-        await this.pm.start();
-        console.log('✓ Daemon started successfully');
+        if (options?.verbose) {
+            console.log('Starting daemon in verbose mode (foreground)...');
+            console.log('Press Ctrl+C to stop the daemon.\n');
+            await this.pm.startForeground();
+        } else {
+            console.log('Starting daemon...');
+            await this.pm.start();
+            console.log('✓ Daemon started successfully');
+        }
     }
 }
+daemon_command_ts_decorate([
+    (0,src.Option)({
+        flags: '-v, --verbose',
+        description: 'Run daemon in foreground with verbose logging'
+    }),
+    daemon_command_ts_metadata("design:type", Function),
+    daemon_command_ts_metadata("design:paramtypes", []),
+    daemon_command_ts_metadata("design:returntype", Boolean)
+], UpSubCommand.prototype, "parseVerbose", null);
 UpSubCommand = daemon_command_ts_decorate([
     (0,src.SubCommand)({
         name: 'up',
@@ -2221,8 +2264,6 @@ SourceManagementService = source_management_service_ts_decorate([
 
 // EXTERNAL MODULE: external "util"
 var external_util_ = __webpack_require__(73);
-// EXTERNAL MODULE: external "child_process"
-var external_child_process_ = __webpack_require__(1020);
 ;// ../../lib/common/src/lib/package-manager.service.ts
 function package_manager_service_ts_decorate(decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
@@ -11205,6 +11246,10 @@ function lazy_plugin_service_ts_metadata(k, v) {
 
 
 
+// Dynamic import that bypasses webpack transformation
+// This is necessary because webpack transforms import() into __webpack_require__()
+// which can't handle truly external modules from user's node_modules
+const dynamicImport = new Function('modulePath', 'return import(modulePath)');
 class LazyPluginService {
     constructor(configService){
         this.configService = configService;
@@ -11275,22 +11320,23 @@ class LazyPluginService {
         const isFileDependency = this.isFileBasedDependency(pluginVersion);
         this.logger.debug(`Plugin is file-based: ${isFileDependency}`);
         try {
-            // Create a require function from the current module
-            const { createRequire: nodeCreateRequire } = await Promise.resolve(/* import() */).then(__webpack_require__.t.bind(__webpack_require__, 1645, 23));
-            const projectRequire = nodeCreateRequire(external_node_path_.resolve(rootDir, 'package.json'));
-            this.logger.debug(`Attempting to load plugin using createRequire: ${this.pluginName}`);
+            this.logger.debug(`Attempting to load plugin: ${this.pluginName}`);
             let mod;
             if (isFileDependency) {
-                // For file-based dependencies, require from the resolved path
+                // For file-based dependencies, import from the resolved path
                 const pluginPath = this.resolvePluginPath(rootDir, pluginVersion);
-                this.logger.debug(`Requiring from file path: ${pluginPath}`);
-                mod = projectRequire(pluginPath);
+                this.logger.debug(`Importing from file path: ${pluginPath}`);
+                mod = await dynamicImport(pluginPath);
             } else {
-                // For npm-based dependencies, require by name (assumes already installed)
-                this.logger.debug(`Requiring npm package: ${this.pluginName}`);
-                mod = projectRequire(this.pluginName);
-            }
-            this.logger.debug(`Module require succeeded`);
+                // For npm-based dependencies, resolve the path first then import
+                // This ensures we load from the project's node_modules, not the daemon's
+                const { createRequire: nodeCreateRequire } = await dynamicImport('node:module');
+                const projectRequire = nodeCreateRequire(external_node_path_.resolve(rootDir, 'package.json'));
+                const resolvedPath = projectRequire.resolve(this.pluginName);
+                this.logger.debug(`Importing npm package from resolved path: ${resolvedPath}`);
+                mod = await dynamicImport(resolvedPath);
+            }
+            this.logger.debug(`Module import succeeded`);
             const factory = this.extractFactory(mod, this.pluginName);
             this.pluginInstance = await Promise.resolve(factory());
             // Validate plugin instance
@@ -11522,8 +11568,10 @@ class OperationsService {
                     ...targetPackage.devDependencies,
                     ...sourcePackage.devDependencies
                 },
-                exports: sourcePackage.exports ?? targetPackage.exports,
-                typesVersions: sourcePackage.typesVersions ?? targetPackage.typesVersions
+                // Keep original plugin exports (pointing to dist/) - don't override with generated exports
+                // The generated SDK code goes to src/ but the plugin entry point must remain dist/
+                exports: targetPackage.exports,
+                typesVersions: targetPackage.typesVersions
             };
             await lib.writeJson(targetFile, merged, {
                 spaces: 2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intrig/core",
-  "version": "0.0.15-23",
+  "version": "0.0.15-25",
   "private": false,
   "type": "module",
   "bin": {