@kubb/agent 4.24.1 → 4.25.1

package/.output/server/chunks/nitro/nitro.mjs

@@ -1,10 +1,15 @@
-import http, { Server as Server$1 } from 'node:http';
+import process from 'node:process';globalThis._importMeta_=globalThis._importMeta_||{url:"file:///_entry.js",env:process.env};import http, { Server as Server$1 } from 'node:http';
 import https, { Server } from 'node:https';
 import { EventEmitter } from 'node:events';
 import { Buffer as Buffer$1 } from 'node:buffer';
-import fs$1, { promises, existsSync } from 'node:fs';
+import fs$1, { promises, existsSync, readFileSync, writeFileSync } from 'node:fs';
 import path$1, { resolve, dirname, join, relative, normalize } from 'node:path';
 import { createHash } from 'node:crypto';
+import process$1, { version as version$2 } from 'node:process';
+import { orderBy } from 'natural-orderby';
+import { execaCommand, execa } from 'execa';
+import pc from 'picocolors';
+import os from 'node:os';
 import { performance } from 'node:perf_hooks';
 import fs from 'fs-extra';
 import { switcher } from 'js-runtime';
@@ -12,15 +17,10 @@ import mod from 'node:module';
 import { createFabric } from '@kubb/react-fabric';
 import { typescriptParser } from '@kubb/react-fabric/parsers';
 import { fsPlugin } from '@kubb/react-fabric/plugins';
-import process$1, { version } from 'node:process';
-import os from 'node:os';
 import { pathToFileURL, fileURLToPath } from 'node:url';
 import { coerce, satisfies } from 'semver';
-import { orderBy } from 'natural-orderby';
-import { execaCommand } from 'execa';
 import { parseArgsStringToArgv } from 'string-argv';
 import { createJiti } from 'jiti';
-import { AsyncLocalStorage } from 'node:async_hooks';
 
 const suspectProtoRx = /"(?:_|\\u0{2}5[Ff]){2}(?:p|\\u0{2}70)(?:r|\\u0{2}72)(?:o|\\u0{2}6[Ff])(?:t|\\u0{2}74)(?:o|\\u0{2}6[Ff])(?:_|\\u0{2}5[Ff]){2}"\s*:/;
 const suspectConstructorRx = /"(?:c|\\u0063)(?:o|\\u006[Ff])(?:n|\\u006[Ee])(?:s|\\u0073)(?:t|\\u0074)(?:r|\\u0072)(?:u|\\u0075)(?:c|\\u0063)(?:t|\\u0074)(?:o|\\u006[Ff])(?:r|\\u0072)"\s*:/;
@@ -4251,9 +4251,9 @@ async function errorHandler(error, event) {
   // H3 will handle fallback
 }
 
-const plugins = [
-  
-];
+function defineNitroPlugin(def) {
+  return def;
+}
 
 var __defProp$1 = Object.defineProperty;
 var __name = (target, value) => __defProp$1(target, "name", {
@@ -5281,16 +5281,382 @@ var __typeError$1 = (msg) => {
 var __accessCheck$1 = (obj, member, msg) => member.has(obj) || __typeError$1("Cannot " + msg);
 var __privateGet$1 = (obj, member, getter) => (__accessCheck$1(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
 var __privateAdd$1 = (obj, member, value) => member.has(obj) ? __typeError$1("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-var __privateSet = (obj, member, value, setter) => (__accessCheck$1(obj, member, "write to private field"), member.set(obj, value), value);
 var __privateMethod$1 = (obj, member, method) => (__accessCheck$1(obj, member, "access private method"), method);
-var _b$1, _cache, _cwd, _SLASHES, _PackageManager_instances, match_fn;
+var _items, _FunctionParams_static, _b$1, orderItems_fn, addParams_fn;
+(_b$1 = class {
+  constructor() {
+    __privateAdd$1(this, _items, []);
+    return this;
+  }
+  get items() {
+    return __privateGet$1(this, _items).flat();
+  }
+  add(item) {
+    if (!item) return this;
+    if (Array.isArray(item)) {
+      item.filter(Boolean).forEach((it) => {
+        __privateGet$1(this, _items).push(it);
+      });
+      return this;
+    }
+    __privateGet$1(this, _items).push(item);
+    return this;
+  }
+  static toObject(items) {
+    var _a2, _b2;
+    let type = [];
+    let name = [];
+    const enabled = items.every((item) => item.enabled) ? (_a2 = items.at(0)) == null ? void 0 : _a2.enabled : true;
+    const required = (_b2 = items.every((item) => item.required)) != null ? _b2 : true;
+    items.forEach((item) => {
+      var _a3, _b3;
+      name = __privateMethod$1(_a3 = _b$1, _FunctionParams_static, addParams_fn).call(_a3, name, {
+        ...item,
+        type: void 0
+      });
+      if (items.some((item$1) => item$1.type)) type = __privateMethod$1(_b3 = _b$1, _FunctionParams_static, addParams_fn).call(_b3, type, item);
+    });
+    return {
+      name: `{ ${name.join(", ")} }`,
+      type: type.length ? `{ ${type.join("; ")} }` : void 0,
+      enabled,
+      required
+    };
+  }
+  toObject() {
+    var _a2;
+    const items = __privateMethod$1(_a2 = _b$1, _FunctionParams_static, orderItems_fn).call(_a2, __privateGet$1(this, _items)).flat();
+    return _b$1.toObject(items);
+  }
+  static toString(items) {
+    var _a2;
+    return __privateMethod$1(_a2 = _b$1, _FunctionParams_static, orderItems_fn).call(_a2, items).reduce((acc, item) => {
+      var _a3, _b2, _c;
+      if (Array.isArray(item)) {
+        if (item.length <= 0) return acc;
+        const subItems = __privateMethod$1(_a3 = _b$1, _FunctionParams_static, orderItems_fn).call(_a3, item);
+        const objectItem = _b$1.toObject(subItems);
+        return __privateMethod$1(_b2 = _b$1, _FunctionParams_static, addParams_fn).call(_b2, acc, objectItem);
+      }
+      return __privateMethod$1(_c = _b$1, _FunctionParams_static, addParams_fn).call(_c, acc, item);
+    }, []).join(", ");
+  }
+  toString() {
+    var _a2;
+    const items = __privateMethod$1(_a2 = _b$1, _FunctionParams_static, orderItems_fn).call(_a2, __privateGet$1(this, _items));
+    return _b$1.toString(items);
+  }
+}, _items = new WeakMap(), _FunctionParams_static = new WeakSet(), orderItems_fn = function(items) {
+  return orderBy(items.filter(Boolean), [(v) => {
+    if (Array.isArray(v)) return;
+    return !v.default;
+  }, (v) => {
+    var _a2;
+    if (Array.isArray(v)) return;
+    return (_a2 = v.required) != null ? _a2 : true;
+  }], ["desc", "desc"]);
+}, addParams_fn = function(acc, item) {
+  const { enabled = true, name, type, required = true, ...rest } = item;
+  if (!enabled) return acc;
+  if (!name) {
+    acc.push(`${type}${rest.default ? ` = ${rest.default}` : ""}`);
+    return acc;
+  }
+  const parameterName = name.startsWith("{") ? name : camelCase(name);
+  if (type) if (required) acc.push(`${parameterName}: ${type}${rest.default ? ` = ${rest.default}` : ""}`);
+  else acc.push(`${parameterName}?: ${type}`);
+  else acc.push(`${parameterName}`);
+  return acc;
+}, __privateAdd$1(_b$1, _FunctionParams_static), _b$1);
+const formatters = {
+  prettier: {
+    command: "prettier",
+    args: (outputPath) => [
+      "--ignore-unknown",
+      "--write",
+      outputPath
+    ],
+    errorMessage: "Prettier not found"
+  },
+  biome: {
+    command: "biome",
+    args: (outputPath) => [
+      "format",
+      "--write",
+      outputPath
+    ],
+    errorMessage: "Biome not found"
+  },
+  oxfmt: {
+    command: "oxfmt",
+    args: (outputPath) => [outputPath],
+    errorMessage: "Oxfmt not found"
+  }
+};
+async function isFormatterAvailable(formatter) {
+  try {
+    await execaCommand(`${formatter} --version`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function detectFormatter() {
+  for (const formatter of [
+    "biome",
+    "oxfmt",
+    "prettier"
+  ]) if (await isFormatterAvailable(formatter)) return formatter;
+}
+function isJSONPlugins(plugins) {
+  return !!(plugins == null ? void 0 : plugins.some((plugin) => {
+    return Array.isArray(plugin) && typeof (plugin == null ? void 0 : plugin.at(0)) === "string";
+  }));
+}
+function isObjectPlugins(plugins) {
+  return plugins instanceof Object && !Array.isArray(plugins);
+}
+function getPlugins(plugins) {
+  if (isObjectPlugins(plugins)) throw new Error("Object plugins are not supported anymore, best to use http://kubb.dev/getting-started/configure#json");
+  if (isJSONPlugins(plugins)) throw new Error("JSON plugins are not supported anymore, best to use http://kubb.dev/getting-started/configure#json");
+  return Promise.resolve(plugins);
+}
+function isPromise(result) {
+  return !!result && typeof (result == null ? void 0 : result.then) === "function";
+}
+async function getConfigs(config, args) {
+  let kubbUserConfig = Promise.resolve(config);
+  if (typeof config === "function") {
+    const possiblePromise = config(args);
+    if (isPromise(possiblePromise)) kubbUserConfig = possiblePromise;
+    kubbUserConfig = Promise.resolve(possiblePromise);
+  }
+  let JSONConfig = await kubbUserConfig;
+  if (!Array.isArray(JSONConfig)) JSONConfig = [JSONConfig];
+  const results = [];
+  for (const item of JSONConfig) {
+    const plugins = item.plugins ? await getPlugins(item.plugins) : void 0;
+    results.push({
+      ...item,
+      plugins
+    });
+  }
+  return results;
+}
+const linters = {
+  eslint: {
+    command: "eslint",
+    args: (outputPath) => [outputPath, "--fix"],
+    errorMessage: "Eslint not found"
+  },
+  biome: {
+    command: "biome",
+    args: (outputPath) => [
+      "lint",
+      "--fix",
+      outputPath
+    ],
+    errorMessage: "Biome not found"
+  },
+  oxlint: {
+    command: "oxlint",
+    args: (outputPath) => ["--fix", outputPath],
+    errorMessage: "Oxlint not found"
+  }
+};
+async function isLinterAvailable(linter) {
+  try {
+    await execaCommand(`${linter} --version`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function detectLinter() {
+  for (const linter of [
+    "biome",
+    "oxlint",
+    "eslint"
+  ]) if (await isLinterAvailable(linter)) return linter;
+}
+function serializePluginOptions(options) {
+  if (options === null || options === void 0) return {};
+  if (typeof options !== "object") return options;
+  if (Array.isArray(options)) return options.map(serializePluginOptions);
+  const serialized = {};
+  for (const [key, value] of Object.entries(options)) {
+    if (typeof value === "function" || typeof value === "symbol" || value === void 0) continue;
+    if (typeof value === "object" && value !== null) serialized[key] = serializePluginOptions(value);
+    else serialized[key] = value;
+  }
+  return serialized;
+}
+
+function isCommandMessage(msg) {
+  return msg.type === "command";
+}
+
+const logger = {
+  info(message, details) {
+    const text = details ? `${message} ${pc.dim(details)}` : message;
+    console.info(`${pc.blue("\u2139")} ${text}`);
+  },
+  success(message, details) {
+    const text = details ? `${message} ${pc.dim(details)}` : message;
+    console.log(`${pc.green("\u2713")} ${text}`);
+  },
+  warn(message, details) {
+    const text = details ? `${message} ${pc.dim(details)}` : message;
+    console.warn(`${pc.yellow("\u26A0")} ${text}`);
+  },
+  error(message, details) {
+    const text = details ? `${message} ${pc.dim(details)}` : message;
+    console.error(`${pc.red("\u2717")} ${text}`);
+  }
+};
+
+const CONFIG_DIR = path$1.join(os.homedir(), ".kubb");
+const CONFIG_FILE = path$1.join(CONFIG_DIR, "config.json");
+function loadAgentConfig() {
+  try {
+    const content = readFileSync(CONFIG_FILE, "utf-8");
+    return JSON.parse(content);
+  } catch (_error) {
+    return { sessions: {} };
+  }
+}
+function saveAgentConfig(config) {
+  try {
+    if (!CONFIG_DIR) {
+      return;
+    }
+    try {
+      writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), "utf-8");
+    } catch {
+      return;
+    }
+  } catch (_error) {
+    logger.warn("Failed to save agent config");
+  }
+}
+function isSessionValid(session) {
+  try {
+    const expiresAt = new Date(session.expiresAt);
+    const now = /* @__PURE__ */ new Date();
+    return now.getTime() < expiresAt.getTime() - 6e4;
+  } catch {
+    return false;
+  }
+}
+function getCachedSession(agentToken) {
+  var _a;
+  try {
+    const config = loadAgentConfig();
+    const sessionKey = hashAgentToken(agentToken);
+    const session = (_a = config.sessions) == null ? void 0 : _a[sessionKey];
+    if (!session) {
+      return null;
+    }
+    if (!isSessionValid(session)) {
+      deleteCachedSession(agentToken);
+      return null;
+    }
+    return session;
+  } catch (_error) {
+    logger.warn("Failed to get cached session");
+    return null;
+  }
+}
+function cacheSession(agentToken, session) {
+  try {
+    const config = loadAgentConfig();
+    const sessionKey = hashAgentToken(agentToken);
+    if (!config.sessions) {
+      config.sessions = {};
+    }
+    config.sessions[sessionKey] = {
+      ...session,
+      storedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    saveAgentConfig(config);
+    logger.success("Cached agent session");
+  } catch (_error) {
+    logger.warn("Failed to cache session");
+  }
+}
+function deleteCachedSession(agentToken) {
+  var _a;
+  try {
+    const config = loadAgentConfig();
+    const sessionKey = hashAgentToken(agentToken);
+    if ((_a = config.sessions) == null ? void 0 : _a[sessionKey]) {
+      delete config.sessions[sessionKey];
+      saveAgentConfig(config);
+    }
+  } catch (_error) {
+    logger.warn("Failed to delete cached session");
+  }
+}
+function hashAgentToken(token) {
+  return createHash("sha512").update(token).digest("hex");
+}
+
+async function createAgentSession({ token, studioUrl, noCache }) {
+  const cachedSession = !noCache ? getCachedSession(token) : null;
+  if (cachedSession) {
+    logger.success("Using cached agent session");
+    return cachedSession;
+  }
+  const connectUrl = `${studioUrl}/api/agent/session/create`;
+  try {
+    const data = await $fetch(connectUrl, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${token}`
+      }
+    });
+    if (data && !noCache) {
+      cacheSession(token, data);
+    }
+    if (!data) {
+      throw new Error("No data available for agent session");
+    }
+    return data;
+  } catch (error) {
+    throw new Error("Failed to get agent session from Kubb Studio", { cause: error });
+  }
+}
+async function disconnect({ sessionToken, token, studioUrl }) {
+  try {
+    const disconnectUrl = `${studioUrl}/api/agent/session/${sessionToken}/disconnect`;
+    await $fetch(disconnectUrl, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${token}`
+      }
+    });
+    logger.success("Sent disconnect notification to Studio on exit");
+  } catch (error) {
+    throw new Error("Failed to notify Studio of disconnection on exit", { cause: error });
+  }
+}
+
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var _b, _cache, _cwd, _SLASHES, _PackageManager_instances, match_fn;
 function isInputPath(config) {
   return typeof (config == null ? void 0 : config.input) === "object" && config.input !== null && "path" in config.input;
 }
-var version$1 = "4.24.1";
+var version$1 = "4.25.1";
 function getDiagnosticInfo() {
   return {
-    nodeVersion: version,
+    nodeVersion: version$2,
     KubbVersion: version$1,
     platform: process.platform,
     arch: process.arch,
@@ -5688,11 +6054,11 @@ function findUpSync(name, options = {}) {
     limit: 1
   })[0];
 }
-(_b$1 = class {
+(_b = class {
   constructor(workspace) {
-    __privateAdd$1(this, _PackageManager_instances);
-    __privateAdd$1(this, _cwd);
-    __privateAdd$1(this, _SLASHES, /* @__PURE__ */ new Set(["/", "\\"]));
+    __privateAdd(this, _PackageManager_instances);
+    __privateAdd(this, _cwd);
+    __privateAdd(this, _SLASHES, /* @__PURE__ */ new Set(["/", "\\"]));
     if (workspace) __privateSet(this, _cwd, workspace);
     return this;
   }
@@ -5700,16 +6066,16 @@ function findUpSync(name, options = {}) {
     __privateSet(this, _cwd, workspace);
   }
   get workspace() {
-    return __privateGet$1(this, _cwd);
+    return __privateGet(this, _cwd);
   }
   normalizeDirectory(directory) {
     const lastChar = directory[directory.length - 1];
-    if (lastChar && !__privateGet$1(this, _SLASHES).has(lastChar)) return `${directory}/`;
+    if (lastChar && !__privateGet(this, _SLASHES).has(lastChar)) return `${directory}/`;
     return directory;
   }
   getLocation(path$1) {
     let location = path$1;
-    if (__privateGet$1(this, _cwd)) location = mod.createRequire(this.normalizeDirectory(__privateGet$1(this, _cwd))).resolve(path$1);
+    if (__privateGet(this, _cwd)) location = mod.createRequire(this.normalizeDirectory(__privateGet(this, _cwd))).resolve(path$1);
     return location;
   }
   async import(path$1) {
@@ -5725,31 +6091,31 @@ function findUpSync(name, options = {}) {
     }
   }
   async getPackageJSON() {
-    const pkgPath = await findUp(["package.json"], { cwd: __privateGet$1(this, _cwd) });
+    const pkgPath = await findUp(["package.json"], { cwd: __privateGet(this, _cwd) });
     if (!pkgPath) return;
     const json = await read(pkgPath);
     return JSON.parse(json);
   }
   getPackageJSONSync() {
-    const pkgPath = findUpSync(["package.json"], { cwd: __privateGet$1(this, _cwd) });
+    const pkgPath = findUpSync(["package.json"], { cwd: __privateGet(this, _cwd) });
     if (!pkgPath) return;
     const json = readSync(pkgPath);
     return JSON.parse(json);
   }
   static setVersion(dependency, version$2) {
-    __privateGet$1(_b$1, _cache)[dependency] = version$2;
+    __privateGet(_b, _cache)[dependency] = version$2;
   }
   async getVersion(dependency) {
-    if (typeof dependency === "string" && __privateGet$1(_b$1, _cache)[dependency]) return __privateGet$1(_b$1, _cache)[dependency];
+    if (typeof dependency === "string" && __privateGet(_b, _cache)[dependency]) return __privateGet(_b, _cache)[dependency];
     const packageJSON = await this.getPackageJSON();
     if (!packageJSON) return;
-    return __privateMethod$1(this, _PackageManager_instances, match_fn).call(this, packageJSON, dependency);
+    return __privateMethod(this, _PackageManager_instances, match_fn).call(this, packageJSON, dependency);
   }
   getVersionSync(dependency) {
-    if (typeof dependency === "string" && __privateGet$1(_b$1, _cache)[dependency]) return __privateGet$1(_b$1, _cache)[dependency];
+    if (typeof dependency === "string" && __privateGet(_b, _cache)[dependency]) return __privateGet(_b, _cache)[dependency];
     const packageJSON = this.getPackageJSONSync();
     if (!packageJSON) return;
-    return __privateMethod$1(this, _PackageManager_instances, match_fn).call(this, packageJSON, dependency);
+    return __privateMethod(this, _PackageManager_instances, match_fn).call(this, packageJSON, dependency);
   }
   async isValid(dependency, version$2) {
     const packageVersion = await this.getVersion(dependency);
@@ -5775,160 +6141,7 @@ function findUpSync(name, options = {}) {
   if (typeof dependency === "string" && dependencies[dependency]) return dependencies[dependency];
   const matchedDependency = Object.keys(dependencies).find((dep) => dep.match(dependency));
   return matchedDependency ? dependencies[matchedDependency] : void 0;
-}, __privateAdd$1(_b$1, _cache, {}), _b$1);
-const LogLevel = {
-  silent: Number.NEGATIVE_INFINITY,
-  error: 0,
-  warn: 1,
-  info: 3,
-  verbose: 4,
-  debug: 5
-};
-
-var __typeError = (msg) => {
-  throw TypeError(msg);
-};
-var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
-var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
-var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
-var _items, _FunctionParams_static, _b, orderItems_fn, addParams_fn;
-(_b = class {
-  constructor() {
-    __privateAdd(this, _items, []);
-    return this;
-  }
-  get items() {
-    return __privateGet(this, _items).flat();
-  }
-  add(item) {
-    if (!item) return this;
-    if (Array.isArray(item)) {
-      item.filter(Boolean).forEach((it) => {
-        __privateGet(this, _items).push(it);
-      });
-      return this;
-    }
-    __privateGet(this, _items).push(item);
-    return this;
-  }
-  static toObject(items) {
-    var _a2, _b2;
-    let type = [];
-    let name = [];
-    const enabled = items.every((item) => item.enabled) ? (_a2 = items.at(0)) == null ? void 0 : _a2.enabled : true;
-    const required = (_b2 = items.every((item) => item.required)) != null ? _b2 : true;
-    items.forEach((item) => {
-      var _a3, _b3;
-      name = __privateMethod(_a3 = _b, _FunctionParams_static, addParams_fn).call(_a3, name, {
-        ...item,
-        type: void 0
-      });
-      if (items.some((item$1) => item$1.type)) type = __privateMethod(_b3 = _b, _FunctionParams_static, addParams_fn).call(_b3, type, item);
-    });
-    return {
-      name: `{ ${name.join(", ")} }`,
-      type: type.length ? `{ ${type.join("; ")} }` : void 0,
-      enabled,
-      required
-    };
-  }
-  toObject() {
-    var _a2;
-    const items = __privateMethod(_a2 = _b, _FunctionParams_static, orderItems_fn).call(_a2, __privateGet(this, _items)).flat();
-    return _b.toObject(items);
-  }
-  static toString(items) {
-    var _a2;
-    return __privateMethod(_a2 = _b, _FunctionParams_static, orderItems_fn).call(_a2, items).reduce((acc, item) => {
-      var _a3, _b2, _c;
-      if (Array.isArray(item)) {
-        if (item.length <= 0) return acc;
-        const subItems = __privateMethod(_a3 = _b, _FunctionParams_static, orderItems_fn).call(_a3, item);
-        const objectItem = _b.toObject(subItems);
-        return __privateMethod(_b2 = _b, _FunctionParams_static, addParams_fn).call(_b2, acc, objectItem);
-      }
-      return __privateMethod(_c = _b, _FunctionParams_static, addParams_fn).call(_c, acc, item);
-    }, []).join(", ");
-  }
-  toString() {
-    var _a2;
-    const items = __privateMethod(_a2 = _b, _FunctionParams_static, orderItems_fn).call(_a2, __privateGet(this, _items));
-    return _b.toString(items);
-  }
-}, _items = new WeakMap(), _FunctionParams_static = new WeakSet(), orderItems_fn = function(items) {
-  return orderBy(items.filter(Boolean), [(v) => {
-    if (Array.isArray(v)) return;
-    return !v.default;
-  }, (v) => {
-    var _a2;
-    if (Array.isArray(v)) return;
-    return (_a2 = v.required) != null ? _a2 : true;
-  }], ["desc", "desc"]);
-}, addParams_fn = function(acc, item) {
-  const { enabled = true, name, type, required = true, ...rest } = item;
-  if (!enabled) return acc;
-  if (!name) {
-    acc.push(`${type}${rest.default ? ` = ${rest.default}` : ""}`);
-    return acc;
-  }
-  const parameterName = name.startsWith("{") ? name : camelCase(name);
-  if (type) if (required) acc.push(`${parameterName}: ${type}${rest.default ? ` = ${rest.default}` : ""}`);
-  else acc.push(`${parameterName}?: ${type}`);
-  else acc.push(`${parameterName}`);
-  return acc;
-}, __privateAdd(_b, _FunctionParams_static), _b);
-function isPromise(result) {
-  return !!result && typeof (result == null ? void 0 : result.then) === "function";
-}
-function serializePluginOptions(options) {
-  if (options === null || options === void 0) return {};
-  if (typeof options !== "object") return options;
-  if (Array.isArray(options)) return options.map(serializePluginOptions);
-  const serialized = {};
-  for (const [key, value] of Object.entries(options)) {
-    if (typeof value === "function" || typeof value === "symbol" || value === void 0) continue;
-    if (typeof value === "object" && value !== null) serialized[key] = serializePluginOptions(value);
-    else serialized[key] = value;
-  }
-  return serialized;
-}
-
-async function isFormatterAvailable(formatter) {
-  try {
-    await execaCommand(`${formatter} --version`, { stdio: "ignore" });
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function detectFormatter() {
-  const formatters2 = ["biome", "oxfmt", "prettier"];
-  for (const formatter of formatters2) {
-    if (await isFormatterAvailable(formatter)) {
-      return formatter;
-    }
-  }
-  return void 0;
-}
-
-async function isLinterAvailable(linter) {
-  try {
-    await execaCommand(`${linter} --version`, { stdio: "ignore" });
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function detectLinter() {
-  const linters = ["biome", "oxlint", "eslint"];
-  for (const linter of linters) {
-    if (await isLinterAvailable(linter)) {
-      return linter;
-    }
-  }
-  return void 0;
-}
+}, __privateAdd(_b, _cache, {}), _b);
 
 async function executeHooks({ hooks, events }) {
   const commands = Array.isArray(hooks.done) ? hooks.done : [hooks.done].filter(Boolean);
@@ -5948,39 +6161,7 @@ async function executeHooks({ hooks, events }) {
   }
 }
 
-const formatters = {
-  prettier: {
-    command: "prettier",
-    args: (outputPath) => ["--ignore-unknown", "--write", outputPath],
-    errorMessage: "Prettier not found"
-  },
-  biome: {
-    command: "biome",
-    args: (outputPath) => ["format", "--write", outputPath],
-    errorMessage: "Biome not found"
-  },
-  oxfmt: {
-    command: "oxfmt",
-    args: (outputPath) => [outputPath],
-    errorMessage: "Oxfmt not found"
-  }
-};
-
-async function generate({ config: userConfig, events, logLevel }) {
-  const hrStart = process$1.hrtime();
-  const config = {
-    ...userConfig,
-    root: userConfig.root || process$1.cwd(),
-    output: {
-      write: true,
-      barrelType: "named",
-      extension: {
-        ".ts": ".ts"
-      },
-      format: "prettier",
-      ...userConfig.output
-    }
-  };
+async function generate({ config, events }) {
   await events.emit("generation:start", config);
   await events.emit("info", config.name ? `Setup generation ${config.name}` : "Setup generation");
   const { sources, fabric, pluginManager } = await setup({
@@ -5988,7 +6169,7 @@ async function generate({ config: userConfig, events, logLevel }) {
     events
   });
   await events.emit("info", config.name ? `Build generation ${config.name}` : "Build generation");
-  const { files, failedPlugins, pluginTimings, error } = await safeBuild(
+  const { files, failedPlugins, error } = await safeBuild(
     {
       config,
       events
@@ -6006,13 +6187,6 @@ async function generate({ config: userConfig, events, logLevel }) {
       events.emit("error", err);
     });
     await events.emit("generation:end", config, files, sources);
-    await events.emit("generation:summary", config, {
-      failedPlugins,
-      filesCreated: files.length,
-      status: failedPlugins.size > 0 || error ? "failed" : "success",
-      hrStart,
-      pluginTimings: void 0
-    });
     throw new Error("Generation failed");
   }
   await events.emit("success", "Generation successfully");
@@ -6031,7 +6205,7 @@ async function generate({ config: userConfig, events, logLevel }) {
     }
     if (formatter && formatter !== "auto" && formatter in formatters) {
       const formatterConfig = formatters[formatter];
-      const outputPath = path$1.resolve(config.root, config.output.path);
+      const outputPath = path$1.isAbsolute(config.output.path) ? config.output.path : path$1.resolve(process.cwd(), config.root, config.output.path);
       try {
         const hookId = createHash("sha256").update([config.name, formatter].filter(Boolean).join("-")).digest("hex");
         await events.emit("hook:start", {
@@ -6060,70 +6234,26 @@ async function generate({ config: userConfig, events, logLevel }) {
         await events.emit("warn", "No linter found (biome, oxlint, or eslint). Skipping linting.");
       } else {
         linter = detectedLinter;
-        await events.emit("info", `Auto-detected linter: ${linter}`);
-      }
-    }
-    if (linter && linter !== "auto") {
-      await events.emit("info", `Linting with ${linter}`);
-      if (linter === "eslint") {
-        try {
-          const hookId = createHash("sha256").update([config.name, linter].filter(Boolean).join("-")).digest("hex");
-          await events.emit("hook:start", {
-            id: hookId,
-            command: "eslint",
-            args: [path$1.resolve(config.root, config.output.path), "--fix"]
-          });
-          await events.onOnce("hook:end", async ({ success, error: error2 }) => {
-            if (!success) {
-              throw error2;
-            }
-            await events.emit("success", "Linted with eslint successfully");
-          });
-        } catch (caughtError) {
-          const error2 = new Error("Eslint not found");
-          error2.cause = caughtError;
-          await events.emit("error", error2);
-        }
-      }
-      if (linter === "biome") {
-        try {
-          const hookId = createHash("sha256").update([config.name, linter].filter(Boolean).join("-")).digest("hex");
-          await events.emit("hook:start", {
-            id: hookId,
-            command: "biome",
-            args: ["lint", "--fix", path$1.resolve(config.root, config.output.path)]
-          });
-          await events.onOnce("hook:end", async ({ success, error: error2 }) => {
-            if (!success) {
-              throw error2;
-            }
-            await events.emit("success", "Linted with biome successfully");
-          });
-        } catch (caughtError) {
-          const error2 = new Error("Biome not found");
-          error2.cause = caughtError;
-          await events.emit("error", error2);
-        }
+        await events.emit("info", `Auto-detected linter: ${pc.dim(linter)}`);
       }
-      if (linter === "oxlint") {
-        try {
-          const hookId = createHash("sha256").update([config.name, linter].filter(Boolean).join("-")).digest("hex");
-          await events.emit("hook:start", {
-            id: hookId,
-            command: "oxlint",
-            args: ["--fix", path$1.resolve(config.root, config.output.path)]
-          });
-          await events.onOnce("hook:end", async ({ success, error: error2 }) => {
-            if (!success) {
-              throw error2;
-            }
-            await events.emit("success", "Linted with oxlint successfully");
-          });
-        } catch (caughtError) {
-          const error2 = new Error("Oxlint not found");
-          error2.cause = caughtError;
-          await events.emit("error", error2);
-        }
+    }
+    if (linter && linter !== "auto" && linter in linters) {
+      const linterConfig = linters[linter];
+      const outputPath = path$1.isAbsolute(config.output.path) ? config.output.path : path$1.resolve(process.cwd(), config.root, config.output.path);
+      try {
+        const hookId = createHash("sha256").update([config.name, linter].filter(Boolean).join("-")).digest("hex");
+        await events.emit("hook:start", {
+          id: hookId,
+          command: linterConfig.command,
+          args: linterConfig.args(outputPath)
+        });
+        await events.onOnce("hook:end", async ({ success, error: error2 }) => {
+          if (!success) throw error2;
+        });
+      } catch (caughtError) {
+        const error2 = new Error(linterConfig.errorMessage);
+        error2.cause = caughtError;
+        await events.emit("error", error2);
       }
     }
     await events.emit("lint:end");
@@ -6133,52 +6263,10 @@ async function generate({ config: userConfig, events, logLevel }) {
     await executeHooks({ hooks: config.hooks, events });
     await events.emit("hooks:end");
   }
-  await events.emit("generation:summary", config, {
-    failedPlugins,
-    filesCreated: files.length,
-    status: failedPlugins.size > 0 || error ? "failed" : "success",
-    hrStart,
-    pluginTimings
-  });
-}
-
-function getPlugins(plugins) {
-  if (plugins instanceof Object && !Array.isArray(plugins)) {
-    throw new Error("Object plugins are not supported anymore, best to use http://kubb.dev/getting-started/configure#json");
-  }
-  if (Array.isArray(plugins) && plugins.some((plugin) => Array.isArray(plugin) && typeof (plugin == null ? void 0 : plugin.at(0)) === "string")) {
-    throw new Error("JSON plugins are not supported anymore, best to use http://kubb.dev/getting-started/configure#json");
-  }
-  return Promise.resolve(plugins);
-}
-async function getConfigs(result) {
-  const config = result == null ? void 0 : result.config;
-  let kubbUserConfig = Promise.resolve(config);
-  if (typeof config === "function") {
-    const possiblePromise = config({});
-    if (isPromise(possiblePromise)) {
-      kubbUserConfig = possiblePromise;
-    } else {
-      kubbUserConfig = Promise.resolve(possiblePromise);
-    }
-  }
-  let JSONConfig = await kubbUserConfig;
-  if (!Array.isArray(JSONConfig)) {
-    JSONConfig = [JSONConfig];
-  }
-  const results = [];
-  for (const item of JSONConfig) {
-    const plugins = item.plugins ? await getPlugins(item.plugins) : void 0;
-    results.push({
-      ...item,
-      plugins
-    });
-  }
-  return results;
 }
 
 const tsLoader = async (configFile) => {
-  const jiti = createJiti(configFile, {
+  const jiti = createJiti(globalThis._importMeta_.url, {
     jsx: {
       runtime: "automatic",
       importSource: "@kubb/react-fabric"
@@ -6202,70 +6290,311 @@ async function getCosmiConfig(configPath) {
   }
 }
 
-const contextStorage = new AsyncLocalStorage();
-let globalContext = null;
-function setGlobalContext(context) {
-  globalContext = context;
-}
-function useKubbAgentContext() {
-  const localContext = contextStorage.getStore();
-  if (localContext) {
-    return localContext;
+const WEBSOCKET_READY = 1;
+const WEBSOCKET_CONNECTING = 0;
+function createWebsocket(url, options) {
+  const ws = new WebSocket(url, options);
+  setTimeout(() => {
+    if (ws.readyState === WEBSOCKET_CONNECTING) {
+      ws.close(3008, "Connection timeout");
+    }
+  }, 5e3);
+  return ws;
+}
+function sendAgentMessage(ws, message) {
+  try {
+    if (ws.readyState !== WEBSOCKET_READY) {
+      return;
+    }
+    ws.send(JSON.stringify(message));
+  } catch (error) {
+    throw new Error("Failed to send message to Kubb Studio", { cause: error });
   }
-  if (globalContext) {
-    return globalContext;
+}
+function setupEventsStream(ws, events) {
+  function sendDataMessage(payload) {
+    sendAgentMessage(ws, {
+      type: "data",
+      payload
+    });
   }
-  throw new Error("Kubb agent context not initialized. Make sure KUBB_CONFIG environment variable is set.");
+  events.on("plugin:start", (plugin) => {
+    sendDataMessage({
+      type: "plugin:start",
+      data: [plugin],
+      timestamp: Date.now()
+    });
+  });
+  events.on("plugin:end", (plugin, meta) => {
+    sendDataMessage({
+      type: "plugin:end",
+      data: [plugin, meta],
+      timestamp: Date.now()
+    });
+  });
+  events.on("files:processing:start", (files) => {
+    sendDataMessage({
+      type: "files:processing:start",
+      data: [{ total: files.length }],
+      timestamp: Date.now()
+    });
+  });
+  events.on("file:processing:update", (meta) => {
+    sendDataMessage({
+      type: "file:processing:update",
+      data: [
+        {
+          file: meta.file.path,
+          processed: meta.processed,
+          total: meta.total,
+          percentage: meta.percentage
+        }
+      ],
+      timestamp: Date.now()
+    });
+  });
+  events.on("files:processing:end", (files) => {
+    sendDataMessage({
+      type: "files:processing:end",
+      data: [{ total: files.length }],
+      timestamp: Date.now()
+    });
+  });
+  events.on("info", (message, info) => {
+    sendDataMessage({
+      type: "info",
+      data: [message, info],
+      timestamp: Date.now()
+    });
+  });
+  events.on("success", (message, info) => {
+    sendDataMessage({
+      type: "success",
+      data: [message, info],
+      timestamp: Date.now()
+    });
+  });
+  events.on("warn", (message, info) => {
+    sendDataMessage({
+      type: "warn",
+      data: [message, info],
+      timestamp: Date.now()
+    });
+  });
+  events.on("generation:start", (config) => {
+    var _a;
+    sendDataMessage({
+      type: "generation:start",
+      data: [
+        {
+          name: config.name,
+          plugins: ((_a = config.plugins) == null ? void 0 : _a.length) || 0
+        }
+      ],
+      timestamp: Date.now()
+    });
+  });
+  events.on("generation:end", (config, files, sources) => {
+    const sourcesRecord = {};
+    sources.forEach((value, key) => {
+      sourcesRecord[key] = value;
+    });
+    sendDataMessage({
+      type: "generation:end",
+      data: [config, files, sourcesRecord],
+      timestamp: Date.now()
+    });
+  });
+  events.on("error", (error) => {
+    sendDataMessage({
+      type: "error",
+      data: [
+        {
+          message: error.message,
+          stack: error.stack
+        }
+      ],
+      timestamp: Date.now()
+    });
+  });
 }
 
-let initialized = false;
-const _nKEgeY = defineEventHandler(async () => {
-  if (!initialized) {
-    initialized = true;
+var version = "4.25.1";
+
+const _zcw7I4pYH8OiCfaDcjy_x7I6IH1tLDQR3W_yRZgP6E = defineNitroPlugin(async (nitro) => {
+  const studioUrl = process$1.env.KUBB_STUDIO_URL || "https://studio.kubb.dev";
+  const token = process$1.env.KUBB_AGENT_TOKEN;
+  const configPath = process$1.env.KUBB_CONFIG || "kubb.config.ts";
+  const noCache = process$1.env.KUBB_AGENT_NO_CACHE === "true";
+  const retryInterval = process$1.env.KUBB_RETRY_TIMEOUT ? Number.parseInt(process$1.env.KUBB_RETRY_TIMEOUT, 10) : 3e4;
+  if (!token) {
+    logger.warn("KUBB_AGENT_TOKEN not set", "cannot authenticate with studio");
+    return null;
+  }
+  const result = await getCosmiConfig(configPath);
+  const configs = await getConfigs(result.config, {});
+  if (configs.length === 0) {
+    throw new Error("No configs found");
+  }
+  const config = configs[0];
+  const events = new AsyncEventEmitter();
+  const wsOptions = {
+    headers: {
+      Authorization: `Bearer ${token}`
+    }
+  };
+  const root = process$1.env.KUBB_ROOT || config.root || process$1.cwd();
+  events.on("hook:start", async ({ id, command, args }) => {
+    const commandWithArgs = (args == null ? void 0 : args.length) ? `${command} ${args.join(" ")}` : command;
+    if (!id) {
+      return;
+    }
     try {
-      const configPath = process.env.KUBB_CONFIG;
-      if (!configPath) {
-        throw new Error("KUBB_CONFIG environment variable not set");
-      }
-      const events = new AsyncEventEmitter();
-      const logLevel = LogLevel.info;
-      const result = await getCosmiConfig(configPath);
-      const configs = await getConfigs(result);
-      if (configs.length === 0) {
-        throw new Error("No configs found");
-      }
-      const config = configs[0];
-      const onGenerate = async () => {
-        await generate({
-          config,
-          events,
-          logLevel
-        });
+      const result2 = await execa(command, args, {
+        cwd: root,
+        detached: true,
+        stripFinalNewline: true
+      });
+      console.log(result2.stdout);
+      await events.emit("hook:end", {
+        command,
+        args,
+        id,
+        success: true,
+        error: null
+      });
+    } catch (_err) {
+      const errorMessage = new Error(`Hook execute failed: ${commandWithArgs}`);
+      await events.emit("hook:end", {
+        command,
+        args,
+        id,
+        success: false,
+        error: errorMessage
+      });
+      await events.emit("error", errorMessage);
+    }
+  });
+  async function reconnectToStudio() {
+    logger.info(`Retrying connection in ${formatMs(retryInterval)} to Kubb Studio ...`);
+    setTimeout(async () => {
+      await connectToStudio();
+    }, retryInterval);
+  }
+  async function connectToStudio() {
+    try {
+      const { sessionToken, wsUrl } = await createAgentSession({ noCache, token, studioUrl });
+      const ws = createWebsocket(wsUrl, wsOptions);
+      const onError = async () => {
+        cleanup();
+        logger.error(`Failed to connect to Kubb Studio on "${wsUrl}"`);
+        const cachedSession = !noCache ? getCachedSession(token) : null;
+        if (cachedSession) {
+          deleteCachedSession(token);
+          await reconnectToStudio();
+        }
       };
-      const context = {
-        config,
-        events,
-        onGenerate
+      const onOpen = () => {
+        logger.success(`Connected to Kubb Studio on "${wsUrl}"`);
       };
-      setGlobalContext(context);
-    } catch (error) {
-      console.error("Failed to initialize Kubb agent context:", error);
-      throw error;
+      const onClose = async () => {
+        cleanup();
+        logger.info("Disconnecting from Studio ...");
+        if (sessionToken) {
+          await disconnect({
+            sessionToken,
+            studioUrl,
+            token
+          }).catch(async () => {
+            deleteCachedSession(token);
+            await reconnectToStudio();
+          });
+        }
+      };
+      const cleanup = () => {
+        ws.removeEventListener("open", onOpen);
+        ws.removeEventListener("close", onClose);
+        ws.removeEventListener("error", onError);
+      };
+      ws.addEventListener("open", onOpen);
+      ws.addEventListener("close", onClose);
+      ws.addEventListener("error", onError);
+      nitro.hooks.hook("close", onClose);
+      setInterval(() => {
+        sendAgentMessage(ws, {
+          type: "ping"
+        });
+      }, 3e4);
+      setupEventsStream(ws, events);
+      ws.addEventListener("message", async (message) => {
+        var _a;
+        const data = JSON.parse(message.data);
+        if (isCommandMessage(data)) {
+          if (data.command === "generate") {
+            await generate({
+              config: {
+                ...config,
+                root
+              },
+              events
+            });
+            logger.success("Generated command success");
+          }
+          if (data.command === "connect") {
+            let specContent;
+            if (config && "path" in config.input) {
+              const specPath = path$1.resolve(process$1.cwd(), config.root, config.input.path);
+              try {
+                specContent = readFileSync(specPath, "utf-8");
+              } catch {
+              }
+            }
+            sendAgentMessage(ws, {
+              type: "connected",
+              payload: {
+                version,
+                configPath: process$1.env.KUBB_CONFIG || "",
+                spec: specContent,
+                config: {
+                  name: config.name,
+                  root: config.root,
+                  input: {
+                    path: "path" in config.input ? config.input.path : void 0
+                  },
+                  output: {
+                    path: config.output.path,
+                    write: config.output.write,
+                    extension: config.output.extension,
+                    barrelType: config.output.barrelType
+                  },
+                  plugins: (_a = config.plugins) == null ? void 0 : _a.map((plugin) => ({
+                    name: `@kubb/${plugin.name}`,
+                    options: serializePluginOptions(plugin.options)
+                  }))
+                }
+              }
+            });
+          }
+          return;
+        }
+        logger.warn(`Unknown message type from Kubb Studio: ${message.data}`);
+      });
+    } catch (_error) {
+      deleteCachedSession(token);
+      await reconnectToStudio();
     }
   }
+  await connectToStudio();
 });
 
-const _lazy_df2682 = () => import('../routes/api/generate.options.mjs');
-const _lazy_nU_FW7 = () => import('../routes/api/generate.post.mjs');
+const plugins = [
+  _zcw7I4pYH8OiCfaDcjy_x7I6IH1tLDQR3W_yRZgP6E
+];
+
 const _lazy_RdtMCE = () => import('../routes/api/health.get.mjs');
-const _lazy_WDQCDr = () => import('../routes/api/info.get.mjs');
 
 const handlers = [
-  { route: '', handler: _nKEgeY, lazy: false, middleware: true, method: undefined },
-  { route: '/api/generate', handler: _lazy_df2682, lazy: true, middleware: false, method: "options" },
-  { route: '/api/generate', handler: _lazy_nU_FW7, lazy: true, middleware: false, method: "post" },
-  { route: '/api/health', handler: _lazy_RdtMCE, lazy: true, middleware: false, method: "get" },
-  { route: '/api/info', handler: _lazy_WDQCDr, lazy: true, middleware: false, method: "get" }
+  { route: '/api/health', handler: _lazy_RdtMCE, lazy: true, middleware: false, method: "get" }
 ];
 
 function createNitroApp() {
@@ -6681,5 +7010,5 @@ trapUnhandledNodeErrors();
 setupGracefulShutdown(listener, nitroApp);
 const nodeServer = {};
 
-export { serializePluginOptions as a, defineEventHandler as d, nodeServer as n, setHeaders as s, useKubbAgentContext as u };
+export { defineEventHandler as d, nodeServer as n, version as v };
 //# sourceMappingURL=nitro.mjs.map