@ultrst-armada/krnl 1.0.1 → 1.0.3

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

@@ -1,400 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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

@@ -1,71 +0,0 @@
-// ../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

@@ -1,71 +0,0 @@
-// ../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

@@ -1,107 +0,0 @@
-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
-};