@ultrst-armada/krnl 0.0.0-stage → 1.0.1

package/packages/create-krnl/dist/chunk-BOXWWXQG.js

@@ -0,0 +1,400 @@
+import {
+  Logger
+} from "./chunk-JTLSTO25.js";
+
+// ../core/dist/chunk-OEINUDSE.js
+import fs from "fs";
+import path from "path";
+import { pathToFileURL } from "url";
+var DefaultServiceContainer = class {
+  services = /* @__PURE__ */ new Map();
+  constructor(initialServices = {}) {
+    for (const [k, v] of Object.entries(initialServices)) {
+      this.services.set(k, v);
+    }
+  }
+  get(serviceName) {
+    return this.services.get(serviceName);
+  }
+  has(serviceName) {
+    return this.services.has(serviceName);
+  }
+  register(serviceName, serviceInstance) {
+    this.services.set(serviceName, serviceInstance);
+  }
+  list() {
+    return Array.from(this.services.keys());
+  }
+};
+var DefaultOperationRegistrar = class {
+  ops = /* @__PURE__ */ new Map();
+  register(op) {
+    if (!op || !op.name) {
+      throw new Error(`[OperationRegistrar] Cannot register operation without a valid name.`);
+    }
+    this.ops.set(op.name, op);
+  }
+  registerBatch(ops) {
+    if (!Array.isArray(ops)) return;
+    for (const op of ops) {
+      this.register(op);
+    }
+  }
+  get(opName) {
+    return this.ops.get(opName);
+  }
+  list() {
+    return Array.from(this.ops.values());
+  }
+};
+var DefaultEventRegistrar = class {
+  hostEntity;
+  constructor(hostEntity) {
+    this.hostEntity = hostEntity;
+  }
+  emit(eventName, data) {
+    if (this.hostEntity && this.hostEntity.interface) {
+      const emitter = this.hostEntity.interface.getEmitter(eventName);
+      if (emitter && typeof emitter.pushDataStreamToEmitter === "function") {
+        emitter.pushDataStreamToEmitter(data);
+        return;
+      }
+    }
+  }
+  on(eventName, listener) {
+    if (this.hostEntity && this.hostEntity.interface) {
+      const emitter = this.hostEntity.interface.getEmitter(eventName);
+      if (emitter && typeof emitter.subscribe === "function") {
+        return emitter.subscribe((msg) => listener(msg.data || msg));
+      }
+    }
+    return () => {
+    };
+  }
+};
+var KrnlSubAppDiscovery = class {
+  /**
+   * Deterministically scans searchDir for sub-apps and builds typed SubAppDescriptor instances.
+   */
+  static async discoverSubApps(searchDir) {
+    const descriptors = [];
+    if (!fs.existsSync(searchDir)) {
+      return descriptors;
+    }
+    const entries = await fs.promises.readdir(searchDir, { withFileTypes: true });
+    for (const dirent of entries) {
+      if (dirent.isDirectory()) {
+        const subAppDir = path.join(searchDir, dirent.name);
+        const desc = await this.locateDescriptor(subAppDir, dirent.name);
+        if (desc) {
+          descriptors.push(desc);
+        }
+      }
+    }
+    return descriptors;
+  }
+  /**
+   * Inspects a specific directory to see if it represents a valid sub-app.
+   */
+  static async locateDescriptor(subAppDir, fallbackId) {
+    if (!fs.existsSync(subAppDir)) return null;
+    let id = fallbackId || path.basename(subAppDir);
+    let manifestPath;
+    let manifest;
+    const subappJsonPath = path.join(subAppDir, "subapp.json");
+    if (fs.existsSync(subappJsonPath)) {
+      try {
+        manifest = JSON.parse(fs.readFileSync(subappJsonPath, "utf-8"));
+        manifestPath = subappJsonPath;
+        if (manifest?.name) id = manifest.name;
+      } catch (e) {
+        console.warn(`[SubAppDiscovery] Failed to parse subapp.json in ${subAppDir}:`, e.message);
+      }
+    }
+    if (!manifest) {
+      const manifestJsonPath = path.join(subAppDir, "manifest.json");
+      if (fs.existsSync(manifestJsonPath)) {
+        try {
+          manifest = JSON.parse(fs.readFileSync(manifestJsonPath, "utf-8"));
+          manifestPath = manifestJsonPath;
+          if (manifest?.name) id = manifest.name;
+        } catch (_) {
+        }
+      }
+    }
+    if (!manifest) {
+      const packageJsonPath = path.join(subAppDir, "package.json");
+      if (fs.existsSync(packageJsonPath)) {
+        try {
+          const pkg = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+          id = pkg.name || id;
+          manifest = {
+            name: pkg.name || id,
+            version: pkg.version || "1.0.0",
+            description: pkg.description,
+            dependencies: pkg.dependencies,
+            devDependencies: pkg.devDependencies
+          };
+          manifestPath = packageJsonPath;
+        } catch (_) {
+        }
+      }
+    }
+    const candidateEntries = [
+      manifest?.registrationEntry,
+      "register.ts",
+      "register.js",
+      "src/register.ts",
+      "src/register.js",
+      "subapp.ts",
+      "subapp.js",
+      "src/subapp.ts",
+      "src/subapp.js",
+      "index.ts",
+      "index.js",
+      "src/index.ts",
+      "src/index.js"
+    ].filter(Boolean);
+    let registrationPath = null;
+    for (const cand of candidateEntries) {
+      const candPath = path.resolve(subAppDir, cand);
+      if (fs.existsSync(candPath)) {
+        registrationPath = candPath;
+        break;
+      }
+    }
+    if (!registrationPath) {
+      return null;
+    }
+    return {
+      id,
+      path: subAppDir,
+      manifestPath,
+      registrationPath,
+      manifest: manifest || { name: id, version: "1.0.0" }
+    };
+  }
+};
+var KrnlSubAppValidator = class {
+  /**
+   * Validates a sub-app manifest.
+   */
+  static validateManifest(manifest) {
+    const errors = [];
+    if (!manifest || typeof manifest !== "object") {
+      errors.push({ code: "INVALID_MANIFEST", message: "Manifest must be an object" });
+      return { valid: false, errors };
+    }
+    if (!manifest.name || typeof manifest.name !== "string" || manifest.name.trim().length === 0) {
+      errors.push({ code: "INVALID_NAME", message: "Manifest requires a non-empty name string", field: "name" });
+    }
+    if (manifest.version && typeof manifest.version !== "string") {
+      errors.push({ code: "INVALID_VERSION", message: "Manifest version must be a string", field: "version" });
+    }
+    if (manifest.dependencies && typeof manifest.dependencies !== "object") {
+      errors.push({ code: "INVALID_DEPENDENCIES", message: "dependencies must be a key-value record", field: "dependencies" });
+    }
+    return { valid: errors.length === 0, errors };
+  }
+  /**
+   * Validates operation definitions and checks for collisions.
+   */
+  static validateRegistration(registration, existingOperations, subAppId) {
+    const errors = [];
+    if (!registration || typeof registration !== "object") {
+      errors.push({ code: "INVALID_REGISTRATION", message: "Registration must return an object with operations", subAppId });
+      return { valid: false, errors };
+    }
+    if (!Array.isArray(registration.operations)) {
+      errors.push({ code: "INVALID_OPERATIONS_ARRAY", message: "Registration operations must be an array", subAppId });
+      return { valid: false, errors };
+    }
+    const seenInBatch = /* @__PURE__ */ new Set();
+    for (const op of registration.operations) {
+      if (!op || typeof op !== "object") {
+        errors.push({ code: "INVALID_OPERATION", message: "Operation definition must be an object", subAppId });
+        continue;
+      }
+      if (!op.name || typeof op.name !== "string" || op.name.trim().length === 0) {
+        errors.push({ code: "INVALID_OP_NAME", message: "Operation requires a non-empty name", subAppId });
+        continue;
+      }
+      if (typeof op.handler !== "function") {
+        errors.push({
+          code: "INVALID_OP_HANDLER",
+          message: `Operation '${op.name}' must have a callable handler function`,
+          subAppId,
+          operationName: op.name
+        });
+      }
+      if (seenInBatch.has(op.name)) {
+        errors.push({
+          code: "DUPLICATE_OP_NAME",
+          message: `Duplicate operation name '${op.name}' inside sub-app registration`,
+          subAppId,
+          operationName: op.name
+        });
+      }
+      seenInBatch.add(op.name);
+      const qualifiedName = `${subAppId}.${op.name}`;
+      if (existingOperations.has(op.name) || existingOperations.has(qualifiedName)) {
+        errors.push({
+          code: "OPERATION_COLLISION",
+          message: `Operation '${op.name}' collides with an existing capability on the host Entity`,
+          subAppId,
+          operationName: op.name
+        });
+      }
+    }
+    return { valid: errors.length === 0, errors };
+  }
+};
+var KrnlSubAppLifecycle = class {
+  /**
+   * Loads, validates, registers, and initializes a sub-app onto an Entity.
+   */
+  static async loadAndRegister(entity, descriptor, config = {}) {
+    const subAppId = descriptor.id;
+    const instance = {
+      id: subAppId,
+      state: "DISCOVERED",
+      manifest: descriptor.manifest || { name: subAppId, version: "1.0.0" },
+      descriptor,
+      operations: /* @__PURE__ */ new Map(),
+      error: null,
+      errorDetails: [],
+      loadedAt: Date.now()
+    };
+    try {
+      instance.state = "VALIDATING";
+      const manifestCheck = KrnlSubAppValidator.validateManifest(instance.manifest);
+      if (!manifestCheck.valid) {
+        instance.state = "ERROR";
+        instance.errorDetails = manifestCheck.errors;
+        instance.error = new Error(`[SubApp:${subAppId}] Manifest validation failed: ${manifestCheck.errors.map((e) => e.message).join(", ")}`);
+        return instance;
+      }
+      instance.state = "LOADING";
+      const fileUrl = pathToFileURL(descriptor.registrationPath).href;
+      const mod = await import(fileUrl);
+      const registerFn = typeof mod.register === "function" ? mod.register : typeof mod.default === "function" ? mod.default : typeof mod.default?.register === "function" ? mod.default.register : null;
+      if (!registerFn) {
+        instance.state = "ERROR";
+        const err = { code: "NO_REGISTER_FUNCTION", message: `No callable register() function exported by ${descriptor.registrationPath}`, subAppId };
+        instance.errorDetails = [err];
+        instance.error = new Error(`[SubApp:${subAppId}] ${err.message}`);
+        return instance;
+      }
+      const serviceContainer = new DefaultServiceContainer({
+        runtimeStore: entity._runtimeStore || null,
+        aiOrchestrator: entity._aiOrchestrator || null
+      });
+      const operationRegistrar = new DefaultOperationRegistrar();
+      const eventRegistrar = new DefaultEventRegistrar(entity);
+      const regContext = {
+        entity,
+        services: serviceContainer,
+        operations: operationRegistrar,
+        events: eventRegistrar,
+        config,
+        logger: Logger
+      };
+      const registrationResult = await registerFn(regContext);
+      const allOps = [
+        ...registrationResult?.operations || [],
+        ...operationRegistrar.list()
+      ];
+      const uniqueOpsMap = /* @__PURE__ */ new Map();
+      for (const op of allOps) {
+        uniqueOpsMap.set(op.name, op);
+      }
+      const uniqueOps = Array.from(uniqueOpsMap.values());
+      const finalRegistration = {
+        ...registrationResult,
+        operations: uniqueOps
+      };
+      const existingCaps = /* @__PURE__ */ new Set();
+      if (entity.localFunctionalities) {
+        for (const k of entity.localFunctionalities.keys()) existingCaps.add(k);
+      }
+      if (entity.remoteFunctionalities) {
+        for (const k of entity.remoteFunctionalities.keys()) existingCaps.add(k);
+      }
+      const opCheck = KrnlSubAppValidator.validateRegistration(finalRegistration, existingCaps, subAppId);
+      if (!opCheck.valid) {
+        instance.state = "ERROR";
+        instance.errorDetails = opCheck.errors;
+        instance.error = new Error(`[SubApp:${subAppId}] Operations validation failed: ${opCheck.errors.map((e) => e.message).join(", ")}`);
+        return instance;
+      }
+      instance.state = "REGISTERED";
+      instance.registration = finalRegistration;
+      for (const op of finalRegistration.operations) {
+        instance.operations.set(op.name, op);
+      }
+      instance.state = "INITIALIZING";
+      if (typeof finalRegistration.onInitialize === "function") {
+        await finalRegistration.onInitialize(regContext);
+      }
+      instance.state = "READY";
+      instance.readyAt = Date.now();
+      return instance;
+    } catch (err) {
+      instance.state = "ERROR";
+      instance.error = err;
+      instance.errorDetails = [{
+        code: "LIFECYCLE_ERROR",
+        message: err.message || String(err),
+        subAppId
+      }];
+      return instance;
+    }
+  }
+  /**
+   * Gracefully unregisters and disposes of a sub-app instance.
+   */
+  static async dispose(instance) {
+    if (instance.state === "DISPOSED") return;
+    instance.state = "UNREGISTERING";
+    try {
+      if (instance.registration && typeof instance.registration.onDispose === "function") {
+        await instance.registration.onDispose();
+      }
+    } catch (e) {
+      console.warn(`[SubApp:${instance.id}] Warning during onDispose():`, e.message);
+    } finally {
+      instance.operations.clear();
+      instance.state = "DISPOSED";
+    }
+  }
+};
+function createHttpsAppAdapter(options) {
+  const operations = options.endpoints.map((ep) => {
+    const cleanName = ep.path.replace(/^\//, "").replace(/^api\//, "").replace(/\//g, "_").replace(/:/g, "") || "root";
+    return {
+      name: cleanName,
+      description: ep.description || `Mapped HTTPS endpoint: ${ep.method || "POST"} ${ep.path}`,
+      method: ep.method || "POST",
+      input: ep.inputSchema,
+      output: ep.outputSchema,
+      metadata: { originalPath: ep.path, originalMethod: ep.method || "POST" },
+      handler: async (input, ctx) => {
+        return await ep.handler(input, ctx);
+      }
+    };
+  });
+  return {
+    name: options.name,
+    operations
+  };
+}
+
+export {
+  DefaultServiceContainer,
+  DefaultOperationRegistrar,
+  DefaultEventRegistrar,
+  KrnlSubAppDiscovery,
+  KrnlSubAppValidator,
+  KrnlSubAppLifecycle,
+  createHttpsAppAdapter
+};

package/packages/create-krnl/dist/chunk-BPTBREBG.js

@@ -0,0 +1,38 @@
+import {
+  __require
+} from "./chunk-QGM4M3NI.js";
+
+// ../core/dist/chunk-KFQGP6VL.js
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require2 = /* @__PURE__ */ ((x) => typeof __require !== "undefined" ? __require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof __require !== "undefined" ? __require : a)[b]
+}) : x)(function(x) {
+  if (typeof __require !== "undefined") return __require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+export {
+  __require2 as __require,
+  __esm,
+  __export,
+  __toCommonJS
+};

package/packages/create-krnl/dist/chunk-FDNCADFE.js

@@ -0,0 +1,71 @@
+// ../core/dist/chunk-HIMEZUU2.js
+var KrnlEntityRegistry = class _KrnlEntityRegistry {
+  static instance = null;
+  entities = /* @__PURE__ */ new Map();
+  constructor() {
+  }
+  /**
+   * Get the singleton instance of the entity registry.
+   */
+  static getInstance() {
+    if (!_KrnlEntityRegistry.instance) {
+      _KrnlEntityRegistry.instance = new _KrnlEntityRegistry();
+    }
+    return _KrnlEntityRegistry.instance;
+  }
+  /**
+   * Registers an entity instance into the global registry.
+   */
+  static register(entity) {
+    const reg = _KrnlEntityRegistry.getInstance();
+    const id = entity.id || entity.entityName;
+    if (id) {
+      reg.entities.set(id, entity);
+    }
+    if (entity.entityName && entity.entityName !== id) {
+      reg.entities.set(entity.entityName, entity);
+    }
+  }
+  /**
+   * Unregisters an entity instance or ID from the registry.
+   */
+  static unregister(entityOrId) {
+    const reg = _KrnlEntityRegistry.getInstance();
+    if (typeof entityOrId === "string") {
+      reg.entities.delete(entityOrId);
+    } else {
+      const id = entityOrId.id || entityOrId.entityName;
+      if (id) reg.entities.delete(id);
+      if (entityOrId.entityName) reg.entities.delete(entityOrId.entityName);
+    }
+  }
+  /**
+   * Retrieves an entity by its ID or name.
+   */
+  static get(idOrName) {
+    return _KrnlEntityRegistry.getInstance().entities.get(idOrName);
+  }
+  /**
+   * Checks if an entity with the given ID or name is registered.
+   */
+  static has(idOrName) {
+    return _KrnlEntityRegistry.getInstance().entities.has(idOrName);
+  }
+  /**
+   * Returns a list of all currently registered unique entities.
+   */
+  static getAll() {
+    const set = new Set(_KrnlEntityRegistry.getInstance().entities.values());
+    return Array.from(set);
+  }
+  /**
+   * Clears all registered entities.
+   */
+  static clear() {
+    _KrnlEntityRegistry.getInstance().entities.clear();
+  }
+};
+
+export {
+  KrnlEntityRegistry
+};

package/packages/create-krnl/dist/chunk-JTLSTO25.js

@@ -0,0 +1,71 @@
+// ../core/dist/chunk-K54K2KZW.js
+import fs from "fs";
+var Logger = class {
+  static log(...args) {
+    console.log(`[${(/* @__PURE__ */ new Date()).toISOString()}]`, ...args);
+  }
+  static error(...args) {
+    console.error(`[${(/* @__PURE__ */ new Date()).toISOString()}] ERROR:`, ...args);
+    this.flush();
+  }
+  static flush() {
+    if (typeof process !== "undefined") {
+      try {
+        if (process.stdout && typeof process.stdout.fd === "number") fs.fsyncSync(process.stdout.fd);
+        if (process.stderr && typeof process.stderr.fd === "number") fs.fsyncSync(process.stderr.fd);
+      } catch (e) {
+      }
+    }
+  }
+};
+var EnumTemplate = {
+  types: [],
+  listTypes() {
+    return Object.freeze([...this.types]);
+  },
+  getTypeID(typeName) {
+    return this[typeName] !== void 0 ? this[typeName] : -1;
+  }
+};
+function createEnum(typeNames) {
+  const enumObj = Object.create(EnumTemplate);
+  enumObj.types = typeNames;
+  typeNames.forEach((name, index) => {
+    enumObj[name] = index;
+  });
+  return Object.freeze(enumObj);
+}
+var krnlSystemTypes = createEnum(["qwnsr", "brnda", "symba", "mosy"]);
+var krnlServiceSuites = createEnum(["UNIFIED_HTTP"]);
+var defaultConnectionBehaviour = createEnum([
+  "allow_unlisted",
+  "ask_key_unlisted",
+  "forbid_unlisted"
+]);
+var krnlServiceSuitePorts = Object.freeze({
+  UNIFIED_HTTP: 1
+});
+var krnlPrimitiveDataTypes = createEnum(["audio", "control-signal", "video", "MIDI", "OSC", "text", "trigger"]);
+var KrnlPolicy = class _KrnlPolicy {
+  maxRetries = 0;
+  timeoutMs = 5e3;
+  retryDelayMs = 1e3;
+  backoffStrategy = "LINEAR";
+  constructor(opts = {}) {
+    if (opts.maxRetries !== void 0) this.maxRetries = opts.maxRetries;
+    if (opts.timeoutMs !== void 0) this.timeoutMs = opts.timeoutMs;
+    if (opts.retryDelayMs !== void 0) this.retryDelayMs = opts.retryDelayMs;
+    if (opts.backoffStrategy !== void 0) this.backoffStrategy = opts.backoffStrategy;
+  }
+  static default() {
+    return new _KrnlPolicy();
+  }
+  static resilient() {
+    return new _KrnlPolicy({ maxRetries: 3, timeoutMs: 1e4, retryDelayMs: 1e3, backoffStrategy: "EXPONENTIAL" });
+  }
+};
+
+export {
+  Logger,
+  KrnlPolicy
+};

package/packages/create-krnl/dist/chunk-M3NCUIPL.js

@@ -0,0 +1,107 @@
+import {
+  krnlSystemEntityBase
+} from "./chunk-N2EONSOC.js";
+import {
+  KrnlShell
+} from "./chunk-3TRM6CYL.js";
+
+// ../core/dist/chunk-ENZ2RQVJ.js
+import fs from "fs";
+import path from "path";
+import http from "http";
+import net from "net";
+var KrnlNonKrnlAppAdapter = class extends krnlSystemEntityBase {
+  childProcess = null;
+  appPort = -1;
+  appPath;
+  constructor(name, appPath) {
+    super(name, null, -1, "127.0.0.1", { Singleton: true, _skipMagneticLoading: true });
+    this.appPath = appPath;
+    this._isIngressNetworkMember = true;
+    this.unifiedHttpAdapter._handleRequest = async (req, res) => {
+      await this.proxyRequest(req, res, req.url || "/");
+    };
+  }
+  async startApp() {
+    this.appPort = await this._probeAvailablePort(11e3, "127.0.0.1");
+    let command = "node";
+    let args = ["."];
+    try {
+      const pkgPath = path.join(this.appPath, "package.json");
+      if (fs.existsSync(pkgPath)) {
+        const packageJson = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+        if (packageJson.scripts?.start) {
+          command = "npm";
+          args = ["run", "start"];
+        } else if (packageJson.main) {
+          args = [packageJson.main];
+        }
+      }
+    } catch (_) {
+    }
+    const env = {
+      ...process.env,
+      PORT: this.appPort.toString()
+    };
+    console.log(`[AppAdapter] Spawning non-Krnl app '${this.entityName}' in background (Port: ${this.appPort})...`);
+    this.childProcess = KrnlShell.spawn(command, args, {
+      cwd: this.appPath,
+      env,
+      stdio: "inherit"
+    });
+    let ready = false;
+    const timeout = 15e3;
+    const start = Date.now();
+    while (Date.now() - start < timeout) {
+      ready = await new Promise((resolve) => {
+        const socket = net.connect(this.appPort, "127.0.0.1");
+        socket.on("connect", () => {
+          socket.destroy();
+          resolve(true);
+        });
+        socket.on("error", () => resolve(false));
+      });
+      if (ready) break;
+      await new Promise((r) => setTimeout(r, 200));
+    }
+    if (!ready) {
+      throw new Error(`[AppAdapter] Non-Krnl app '${this.entityName}' failed to boot on port ${this.appPort} within 15s.`);
+    }
+    console.log(`[AppAdapter] Non-Krnl app '${this.entityName}' successfully booted.`);
+  }
+  async proxyRequest(req, res, subPath) {
+    if (this.appPort === -1) {
+      res.writeHead(503, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ status: "error", message: "Service Temporarily Unavailable: Sub-app not running." }));
+      return;
+    }
+    const options = {
+      hostname: "127.0.0.1",
+      port: this.appPort,
+      path: subPath,
+      method: req.method,
+      headers: req.headers
+    };
+    const proxyReq = http.request(options, (proxyRes) => {
+      res.writeHead(proxyRes.statusCode || 500, proxyRes.headers);
+      proxyRes.pipe(res);
+    });
+    proxyReq.on("error", (err) => {
+      res.writeHead(502, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ status: "error", message: `Bad Gateway: ${err.message}` }));
+    });
+    req.pipe(proxyReq);
+  }
+  dispose() {
+    if (this.childProcess) {
+      console.log(`[AppAdapter] Killing child process (PID: ${this.childProcess.pid}) for '${this.entityName}'`);
+      this.childProcess.kill("SIGTERM");
+      this.childProcess = null;
+    }
+    super.dispose();
+  }
+};
+
+export {
+  KrnlNonKrnlAppAdapter
+};