@kwirthmagnify/kwirth-provider-http-pull-push 0.1.0

package/back.js

@@ -0,0 +1,546 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/back/index.ts
+var index_exports = {};
+__export(index_exports, {
+  HttpPullPushProvider: () => HttpPullPushProvider,
+  default: () => index_default
+});
+module.exports = __toCommonJS(index_exports);
+var import_express = __toESM(require("express"), 1);
+
+// src/common/HttpPullPush.ts
+var TEST_PREVIEW_CHARS = 1500;
+
+// src/common/Validation.ts
+var validateForTest = (config) => {
+  const errors = [];
+  if (!config) return ["No connection to test"];
+  if (!config.url || !/^https?:\/\//i.test(config.url)) errors.push("url must start with http:// or https://");
+  if (!(config.timeoutMs > 0)) errors.push("timeout must be greater than zero");
+  switch (config.auth?.type) {
+    case "basic" /* BASIC */:
+      if (!config.auth.username) errors.push("basic auth needs a username");
+      break;
+    case "bearer" /* BEARER */:
+      if (!config.auth.token) errors.push("bearer auth needs a token");
+      break;
+    case "header" /* HEADER */:
+      if (!config.auth.headerName) errors.push("header auth needs a header name");
+      break;
+    default:
+      break;
+  }
+  return errors;
+};
+var validateConfigs = (configs) => {
+  const errors = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const config of configs) {
+    const name = (config.name ?? "").trim();
+    if (!name) {
+      errors.push("A connection has no name");
+      continue;
+    }
+    if (seen.has(name)) errors.push(`Duplicated connection name: '${name}'`);
+    seen.add(name);
+    if (!config.url || !/^https?:\/\//i.test(config.url)) errors.push(`'${name}': url must start with http:// or https://`);
+    if (!(config.intervalSeconds > 0)) errors.push(`'${name}': interval must be greater than zero`);
+    if (!(config.timeoutMs > 0)) errors.push(`'${name}': timeout must be greater than zero`);
+    if (config.retries < 0) errors.push(`'${name}': retries cannot be negative`);
+    if (config.timeoutMs > config.intervalSeconds * 1e3) errors.push(`'${name}': timeout is longer than the polling interval`);
+    switch (config.auth?.type) {
+      case "basic" /* BASIC */:
+        if (!config.auth.username) errors.push(`'${name}': basic auth needs a username`);
+        break;
+      case "bearer" /* BEARER */:
+        if (!config.auth.token) errors.push(`'${name}': bearer auth needs a token`);
+        break;
+      case "header" /* HEADER */:
+        if (!config.auth.headerName) errors.push(`'${name}': header auth needs a header name`);
+        break;
+      case "none" /* NONE */:
+      case void 0:
+        break;
+      default:
+        errors.push(`'${name}': unknown auth type`);
+    }
+  }
+  return errors;
+};
+
+// src/back/ConfigStore.ts
+var STORAGE_CONFIGS = "http-pull-push-configs";
+var STORAGE_CREDS = "http-pull-push-creds";
+var splitAuth = (auth) => {
+  const { password, token, headerValue, ...rest } = auth ?? { type: "none" /* NONE */ };
+  const secretPart = {};
+  if (password) secretPart.password = password;
+  if (token) secretPart.token = token;
+  if (headerValue) secretPart.headerValue = headerValue;
+  return { publicPart: rest, secretPart };
+};
+var ConfigStore = class {
+  constructor(storage) {
+    this.load = async () => {
+      if (!this.storage) return [];
+      const configs = await this.storage.readStorage(STORAGE_CONFIGS, false) ?? [];
+      const creds = await this.storage.readStorage(STORAGE_CREDS, true) ?? {};
+      return configs.map((config) => {
+        const credential = creds[config.name];
+        if (!credential) return config;
+        return {
+          ...config,
+          auth: {
+            ...config.auth,
+            ...credential.password ? { password: credential.password } : {},
+            ...credential.token ? { token: credential.token } : {},
+            ...credential.headerValue ? { headerValue: credential.headerValue } : {}
+          }
+        };
+      });
+    };
+    this.save = async (configs) => {
+      if (!this.storage) throw new Error("no storage available: this provider needs a Kwirth core that injects provider storage");
+      const publicConfigs = [];
+      const creds = {};
+      for (const config of configs) {
+        const { publicPart, secretPart } = splitAuth(config.auth);
+        publicConfigs.push({ ...config, auth: publicPart });
+        if (Object.keys(secretPart).length > 0) creds[config.name] = secretPart;
+      }
+      await this.storage.writeStorage(STORAGE_CONFIGS, false, publicConfigs);
+      await this.storage.writeStorage(STORAGE_CREDS, true, creds);
+    };
+    this.storage = storage;
+  }
+  get available() {
+    return this.storage !== void 0;
+  }
+};
+
+// src/back/HttpFetcher.ts
+var import_http = __toESM(require("http"), 1);
+var import_https = __toESM(require("https"), 1);
+var METHODS_WITH_BODY = ["POST" /* POST */, "PUT" /* PUT */, "PATCH" /* PATCH */];
+var buildHeaders = (config) => {
+  const headers = { ...config.headers ?? {} };
+  const auth = config.auth;
+  if (!auth) return headers;
+  switch (auth.type) {
+    case "basic" /* BASIC */:
+      headers["Authorization"] = "Basic " + Buffer.from(`${auth.username ?? ""}:${auth.password ?? ""}`, "utf8").toString("base64");
+      break;
+    case "bearer" /* BEARER */:
+      headers["Authorization"] = `Bearer ${auth.token ?? ""}`;
+      break;
+    case "header" /* HEADER */:
+      if (auth.headerName) headers[auth.headerName] = auth.headerValue ?? "";
+      break;
+    case "none" /* NONE */:
+      break;
+  }
+  return headers;
+};
+var httpFetcher = (config) => {
+  return new Promise((resolve, reject) => {
+    let url;
+    try {
+      url = new URL(config.url);
+    } catch {
+      reject(new Error(`invalid url '${config.url}'`));
+      return;
+    }
+    const isHttps = url.protocol === "https:";
+    const transport = isHttps ? import_https.default : import_http.default;
+    const headers = buildHeaders(config);
+    const hasBody = METHODS_WITH_BODY.includes(config.method) && config.body !== void 0;
+    if (hasBody && !headers["Content-Type"]) headers["Content-Type"] = "application/json";
+    const request = transport.request({
+      protocol: url.protocol,
+      hostname: url.hostname,
+      port: url.port || (isHttps ? 443 : 80),
+      path: url.pathname + url.search,
+      method: config.method,
+      headers,
+      ...isHttps && config.allowInsecureTls ? { rejectUnauthorized: false } : {}
+    }, (response) => {
+      const chunks = [];
+      response.on("data", (chunk) => chunks.push(chunk));
+      response.on("end", () => {
+        resolve({
+          status: response.statusCode ?? 0,
+          body: Buffer.concat(chunks).toString("utf8")
+        });
+      });
+    });
+    request.setTimeout(config.timeoutMs, () => {
+      request.destroy(new Error(`timeout after ${config.timeoutMs}ms`));
+    });
+    request.on("error", (err) => reject(err));
+    if (hasBody) request.write(config.body);
+    request.end();
+  });
+};
+
+// src/back/Poller.ts
+var fingerprint = (config) => {
+  const headers = Object.keys(config.headers ?? {}).sort().map((k) => `${k}=${config.headers[k]}`).join("&");
+  const auth = config.auth ?? {};
+  return [
+    config.url,
+    config.method,
+    headers,
+    config.body ?? "",
+    config.intervalSeconds,
+    config.timeoutMs,
+    auth.type,
+    auth.username ?? "",
+    auth.password ?? "",
+    auth.token ?? "",
+    auth.headerName ?? "",
+    auth.headerValue ?? "",
+    config.responseType,
+    config.emitMode,
+    config.retries,
+    config.allowInsecureTls
+  ].join("|");
+};
+var Poller = class {
+  constructor(config, fetcher, onEvent) {
+    this.running = false;
+    this.start = () => {
+      if (this.timer) return;
+      void this.tick();
+      this.timer = setInterval(() => {
+        void this.tick();
+      }, this.config.intervalSeconds * 1e3);
+    };
+    this.stop = () => {
+      if (this.timer) clearInterval(this.timer);
+      this.timer = void 0;
+    };
+    // ¿Sigue sirviendo este poller para la configuracion dada, o hay que recrearlo?
+    this.matches = (config) => fingerprint(this.config) === fingerprint(config);
+    // Un ciclo. Si el anterior sigue en vuelo se salta este, para no encadenar peticiones sobre un
+    // endpoint lento (el intervalo manda, no la latencia).
+    this.tick = async () => {
+      if (this.running) return;
+      this.running = true;
+      try {
+        const result = await this.fetchWithRetries();
+        const data = this.parse(result.body);
+        if (!this.shouldEmit(result.status, result.body)) return;
+        this.onEvent({
+          config: this.config.name,
+          timestamp: Date.now(),
+          status: result.status,
+          data
+        });
+      } catch (err) {
+        this.lastPayload = void 0;
+        this.onEvent({
+          config: this.config.name,
+          timestamp: Date.now(),
+          error: err instanceof Error ? err.message : String(err)
+        });
+      } finally {
+        this.running = false;
+      }
+    };
+    this.fetchWithRetries = async () => {
+      let lastError;
+      for (let attempt = 0; attempt <= this.config.retries; attempt++) {
+        try {
+          return await this.fetcher(this.config);
+        } catch (err) {
+          lastError = err;
+        }
+      }
+      throw lastError;
+    };
+    this.parse = (body) => {
+      if (this.config.responseType === "text" /* TEXT */) return body;
+      try {
+        return JSON.parse(body);
+      } catch {
+        return body;
+      }
+    };
+    // En modo onChange se compara el cuerpo crudo con el del ciclo anterior: es exacto y no depende de
+    // como serialice el objeto parseado.
+    this.shouldEmit = (status, body) => {
+      if (this.config.emitMode === "always" /* ALWAYS */) return true;
+      const payload = `${status}:${body}`;
+      if (this.lastPayload === payload) return false;
+      this.lastPayload = payload;
+      return true;
+    };
+    this.config = config;
+    this.fetcher = fetcher;
+    this.onEvent = onEvent;
+  }
+};
+
+// src/back/index.ts
+var HttpPullPushProvider = class {
+  constructor(_clusterInfo, _kwirthData, storage, fetcher = httpFetcher) {
+    this.id = "http-pull-push";
+    this.providesRouter = false;
+    this.router = void 0;
+    this.routerAlias = void 0;
+    this.requiresApiKeyApi = false;
+    this.apiKeyApi = void 0;
+    this.configRouter = import_express.default.Router();
+    this.configs = /* @__PURE__ */ new Map();
+    this.subscribers = /* @__PURE__ */ new Map();
+    this.pollers = /* @__PURE__ */ new Map();
+    this.started = false;
+    // ── IProvider ───────────────────────────────────────────────────────────────
+    this.startProvider = async () => {
+      try {
+        const configs = await this.store.load();
+        this.configs = new Map(configs.map((c) => [c.name, c]));
+        console.log(`[http-pull-push] ${this.configs.size} connection(s) loaded`);
+      } catch (err) {
+        console.error(`[http-pull-push] Could not load connections: ${err}`);
+      }
+      this.started = true;
+      this.reconcile();
+    };
+    this.stopProvider = async () => {
+      for (const poller of this.pollers.values()) poller.stop();
+      this.pollers.clear();
+      this.subscribers.clear();
+      this.started = false;
+    };
+    this.addSubscriber = async (c, data) => {
+      this.subscribers.set(c, { configs: this.parseSelection(data) });
+      this.warnUnknown(data);
+      this.reconcile();
+    };
+    this.removeSubscriber = async (c) => {
+      this.subscribers.delete(c);
+      this.reconcile();
+    };
+    // Permite a un canal cambiar su seleccion sin desuscribirse y volver a suscribirse.
+    this.updateSubscription = async (c, data) => {
+      if (!this.subscribers.has(c)) return;
+      this.subscribers.set(c, { configs: this.parseSelection(data) });
+      this.warnUnknown(data);
+      this.reconcile();
+    };
+    /*
+        Ayuda para quien se suscribe. Merece la pena declararla porque la semantica de 'configs' no se
+        adivina: un array VACIO no significa "todo", significa "nada"; y las conexiones las crea un
+        administrador en el dialogo del provider, asi que hay que decir sus nombres.
+    */
+    this.getSubscriptionHelp = () => ({
+      usage: `Subscribe by CONNECTION NAME. The connections are created by an administrator in this provider's dialog (gear in Manage extensions > Providers), so their names are the ones listed there.
+
+Selection semantics:
+  - configs: ["a","b"]  -> only those connections
+  - configs: []         -> NOTHING is delivered (an empty array is not "everything")
+  - configs absent      -> every enabled connection, including ones created later
+
+Each event arrives wrapped, so a subscriber to several connections can tell them apart:
+  success: { config, timestamp, status, data }   data = parsed body (json) or raw text
+  failure: { config, timestamp, error }          no data, no status
+
+Gotchas:
+  - Polling is LAZY: a connection is only polled while at least one subscriber wants it, so nothing happens until you subscribe (and the first pull is immediate).
+  - A DISABLED connection delivers nothing even if you name it explicitly.
+  - Naming a connection that does not exist is ignored and logged, never an error.
+  - With emitMode=onChange the connection stays quiet while the answer is identical.`,
+      example: { configs: ["stocks", "rss"] },
+      fields: [
+        {
+          name: "configs",
+          type: "string[]",
+          description: "Connection names to receive. Empty array = nothing; omit the field = all enabled connections."
+        }
+      ]
+    });
+    // ── Configuracion (capa 1) ──────────────────────────────────────────────────
+    this.addConfigRoutes = () => {
+      this.configRouter.route("/configs").get(async (_req, res) => {
+        res.status(200).json([...this.configs.values()]);
+      }).put(async (req, res) => {
+        try {
+          const incoming = req.body;
+          if (!Array.isArray(incoming)) {
+            res.status(400).json({ errors: ["Body must be an array of connections"] });
+            return;
+          }
+          const errors = validateConfigs(incoming);
+          if (errors.length > 0) {
+            res.status(400).json({ errors });
+            return;
+          }
+          await this.applyConfigs(incoming);
+          res.status(200).json({ ok: true });
+        } catch (err) {
+          console.error(`[http-pull-push] Error saving connections: ${err}`);
+          res.status(500).json({ errors: [String(err)] });
+        }
+      });
+      this.configRouter.route("/test").post(async (req, res) => {
+        try {
+          const result = await this.testConnection(req.body);
+          res.status(200).json(result);
+        } catch (err) {
+          console.error(`[http-pull-push] Error testing connection: ${err}`);
+          res.status(500).json({ ok: false, durationMs: 0, error: String(err) });
+        }
+      });
+    };
+    /*
+            Prueba una conexion HACIENDO LA PETICION DE VERDAD, una sola vez y sin persistir nada.
+    
+            La ejecuta el back a proposito: es el back quien tiene la red del cluster, los certificados y la
+            identidad con los que se hara el pull real, asi que probar desde el navegador no demostraria nada
+            (otra red, otro almacen de CAs, otras reglas de salida).
+    
+            Se ignoran los reintentos: en una prueba interesa el primer resultado, no la insistencia.
+        */
+    this.testConnection = async (config) => {
+      const errors = validateForTest(config);
+      if (errors.length > 0) return { ok: false, durationMs: 0, error: errors.join("; ") };
+      const started = Date.now();
+      try {
+        const result = await this.fetcher({ ...config, retries: 0 });
+        const body = result.body ?? "";
+        let jsonParsed = false;
+        try {
+          JSON.parse(body);
+          jsonParsed = true;
+        } catch {
+        }
+        return {
+          ok: true,
+          status: result.status,
+          durationMs: Date.now() - started,
+          bytes: Buffer.byteLength(body, "utf8"),
+          preview: body.slice(0, TEST_PREVIEW_CHARS),
+          jsonParsed
+        };
+      } catch (err) {
+        return {
+          ok: false,
+          durationMs: Date.now() - started,
+          error: err instanceof Error ? err.message : String(err)
+        };
+      }
+    };
+    /*
+        Guarda y aplica en caliente: no hay que reiniciar Kwirth para que una conexion nueva empiece a
+        consultarse, ni para que una que se deshabilita deje de hacerlo.
+    */
+    this.applyConfigs = async (configs) => {
+      await this.store.save(configs);
+      this.configs = new Map(configs.map((c) => [c.name, c]));
+      this.reconcile();
+    };
+    this.getConfigs = () => [...this.configs.values()];
+    // Solo los nombres: alimenta el contador de la tarjeta en el gestor de extensiones.
+    this.getConfigNames = () => [...this.configs.keys()];
+    // ── Reconciliacion de pollers ───────────────────────────────────────────────
+    /*
+        Deja los pollers en marcha exactamente iguales a lo que dicen la configuracion y las suscripciones:
+        arranca los que faltan, para los que sobran y recrea los que han cambiado de parametros.
+    */
+    this.reconcile = () => {
+      if (!this.started) return;
+      for (const [name, poller] of this.pollers) {
+        const config = this.configs.get(name);
+        if (!config || !this.shouldRun(config)) {
+          poller.stop();
+          this.pollers.delete(name);
+        }
+      }
+      for (const config of this.configs.values()) {
+        if (!this.shouldRun(config)) continue;
+        const existing = this.pollers.get(config.name);
+        if (existing) {
+          if (!existing.matches(config)) {
+            existing.stop();
+            this.pollers.delete(config.name);
+          } else {
+            continue;
+          }
+        }
+        const poller = new Poller(config, this.fetcher, (event) => this.dispatch(event));
+        this.pollers.set(config.name, poller);
+        poller.start();
+      }
+    };
+    this.shouldRun = (config) => {
+      if (!config.enabled) return false;
+      return this.countListeners(config.name) > 0;
+    };
+    this.countListeners = (name) => {
+      let count = 0;
+      for (const entry of this.subscribers.values()) {
+        if (entry.configs === void 0 || entry.configs.has(name)) count++;
+      }
+      return count;
+    };
+    // ── Entrega (capa 2) ────────────────────────────────────────────────────────
+    this.dispatch = (event) => {
+      for (const [subscriber, entry] of this.subscribers) {
+        if (entry.configs !== void 0 && !entry.configs.has(event.config)) continue;
+        try {
+          subscriber.processProviderEvent(this.id, event);
+        } catch (err) {
+          console.error(`[http-pull-push] Subscriber failed processing '${event.config}': ${err}`);
+        }
+      }
+    };
+    this.parseSelection = (data) => {
+      if (!data || data.configs === void 0) return void 0;
+      return new Set(data.configs);
+    };
+    // Suscribirse a algo que no existe (o que se borro despues) no es un error: se ignora y se deja traza.
+    this.warnUnknown = (data) => {
+      if (!data?.configs) return;
+      for (const name of data.configs) {
+        if (!this.configs.has(name)) console.log(`[http-pull-push] Subscription to unknown connection '${name}' \u2014 ignored`);
+      }
+    };
+    this.store = new ConfigStore(storage);
+    this.fetcher = fetcher;
+    this.addConfigRoutes();
+  }
+};
+var index_default = HttpPullPushProvider;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HttpPullPushProvider
+});

package/front.js

@@ -0,0 +1,661 @@
+"use strict";
+(() => {
+  var __create = Object.create;
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getProtoOf = Object.getPrototypeOf;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __commonJS = (cb, mod) => function __require() {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  };
+  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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+    // If the importer is in node compatibility mode or this is not an ESM
+    // file that has been converted to a CommonJS file using a Babel-
+    // compatible transform (i.e. "__esModule" has not been set), then set
+    // "default" to the CommonJS "module.exports" for node compatibility.
+    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+    mod
+  ));
+
+  // kwirth-globals:react
+  var require_react = __commonJS({
+    "kwirth-globals:react"(exports, module) {
+      module.exports = window.__kwirth__.React;
+    }
+  });
+
+  // kwirth-globals:@mui/material
+  var require_material = __commonJS({
+    "kwirth-globals:@mui/material"(exports, module) {
+      module.exports = window.__kwirth__.MUI.material;
+    }
+  });
+
+  // kwirth-globals:@mui/icons-material
+  var require_icons_material = __commonJS({
+    "kwirth-globals:@mui/icons-material"(exports, module) {
+      module.exports = window.__kwirth__.MUI.icons;
+    }
+  });
+
+  // src/front/HttpPullPushConfigDialog.tsx
+  var import_react3 = __toESM(require_react(), 1);
+  var import_material3 = __toESM(require_material(), 1);
+  var import_icons_material3 = __toESM(require_icons_material(), 1);
+
+  // src/common/HttpPullPush.ts
+  var EHttpMethod = /* @__PURE__ */ ((EHttpMethod2) => {
+    EHttpMethod2["GET"] = "GET";
+    EHttpMethod2["POST"] = "POST";
+    EHttpMethod2["PUT"] = "PUT";
+    EHttpMethod2["PATCH"] = "PATCH";
+    EHttpMethod2["DELETE"] = "DELETE";
+    return EHttpMethod2;
+  })(EHttpMethod || {});
+  var DEFAULT_INTERVAL_SECONDS = 60;
+  var DEFAULT_TIMEOUT_MS = 1e4;
+  var newHttpPullConfig = (name) => ({
+    name,
+    enabled: true,
+    url: "",
+    method: "GET" /* GET */,
+    headers: {},
+    intervalSeconds: DEFAULT_INTERVAL_SECONDS,
+    timeoutMs: DEFAULT_TIMEOUT_MS,
+    auth: { type: "none" /* NONE */ },
+    responseType: "json" /* JSON */,
+    emitMode: "always" /* ALWAYS */,
+    retries: 0,
+    allowInsecureTls: false
+  });
+
+  // src/common/Validation.ts
+  var validateConfigs = (configs) => {
+    const errors = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const config of configs) {
+      const name = (config.name ?? "").trim();
+      if (!name) {
+        errors.push("A connection has no name");
+        continue;
+      }
+      if (seen.has(name)) errors.push(`Duplicated connection name: '${name}'`);
+      seen.add(name);
+      if (!config.url || !/^https?:\/\//i.test(config.url)) errors.push(`'${name}': url must start with http:// or https://`);
+      if (!(config.intervalSeconds > 0)) errors.push(`'${name}': interval must be greater than zero`);
+      if (!(config.timeoutMs > 0)) errors.push(`'${name}': timeout must be greater than zero`);
+      if (config.retries < 0) errors.push(`'${name}': retries cannot be negative`);
+      if (config.timeoutMs > config.intervalSeconds * 1e3) errors.push(`'${name}': timeout is longer than the polling interval`);
+      switch (config.auth?.type) {
+        case "basic" /* BASIC */:
+          if (!config.auth.username) errors.push(`'${name}': basic auth needs a username`);
+          break;
+        case "bearer" /* BEARER */:
+          if (!config.auth.token) errors.push(`'${name}': bearer auth needs a token`);
+          break;
+        case "header" /* HEADER */:
+          if (!config.auth.headerName) errors.push(`'${name}': header auth needs a header name`);
+          break;
+        case "none" /* NONE */:
+        case void 0:
+          break;
+        default:
+          errors.push(`'${name}': unknown auth type`);
+      }
+    }
+    return errors;
+  };
+
+  // src/front/HeaderEditor.tsx
+  var import_react = __toESM(require_react(), 1);
+  var import_material = __toESM(require_material(), 1);
+  var import_icons_material = __toESM(require_icons_material(), 1);
+  var HeaderEditor = ({ headers, onChange }) => {
+    const [name, setName] = (0, import_react.useState)("");
+    const [value, setValue] = (0, import_react.useState)("");
+    const entries = Object.entries(headers ?? {});
+    const add = () => {
+      const key = name.trim();
+      if (!key) return;
+      onChange({ ...headers, [key]: value });
+      setName("");
+      setValue("");
+    };
+    const remove = (key) => {
+      const next = { ...headers };
+      delete next[key];
+      onChange(next);
+    };
+    return /* @__PURE__ */ import_react.default.createElement(import_material.Box, null, /* @__PURE__ */ import_react.default.createElement(import_material.Typography, { variant: "subtitle2", sx: { mb: 1 } }, "Headers"), /* @__PURE__ */ import_react.default.createElement(import_material.Stack, { spacing: 0.5, sx: { mb: 1 } }, entries.length === 0 && /* @__PURE__ */ import_react.default.createElement(import_material.Typography, { variant: "body2", color: "text.secondary" }, "No headers."), entries.map(([key, val]) => /* @__PURE__ */ import_react.default.createElement(
+      import_material.Stack,
+      {
+        key,
+        direction: "row",
+        alignItems: "center",
+        spacing: 1,
+        sx: { px: 1, py: 0.5, border: 1, borderColor: "divider", borderRadius: 1 }
+      },
+      /* @__PURE__ */ import_react.default.createElement(import_material.Typography, { variant: "body2", sx: { fontWeight: 500, minWidth: 140 } }, key),
+      /* @__PURE__ */ import_react.default.createElement(import_material.Typography, { variant: "body2", sx: { flex: 1, wordBreak: "break-all" } }, val),
+      /* @__PURE__ */ import_react.default.createElement(import_material.Tooltip, { title: "Remove header" }, /* @__PURE__ */ import_react.default.createElement(import_material.IconButton, { size: "small", color: "error", onClick: () => remove(key) }, /* @__PURE__ */ import_react.default.createElement(import_icons_material.Delete, { fontSize: "small" })))
+    ))), /* @__PURE__ */ import_react.default.createElement(import_material.Stack, { direction: "row", spacing: 1, alignItems: "center" }, /* @__PURE__ */ import_react.default.createElement(
+      import_material.TextField,
+      {
+        size: "small",
+        label: "Name",
+        value: name,
+        sx: { width: 180 },
+        onChange: (e) => setName(e.target.value)
+      }
+    ), /* @__PURE__ */ import_react.default.createElement(
+      import_material.TextField,
+      {
+        size: "small",
+        label: "Value",
+        value,
+        sx: { flex: 1 },
+        onChange: (e) => setValue(e.target.value)
+      }
+    ), /* @__PURE__ */ import_react.default.createElement(import_material.Tooltip, { title: "Add header" }, /* @__PURE__ */ import_react.default.createElement("span", null, /* @__PURE__ */ import_react.default.createElement(import_material.IconButton, { size: "small", onClick: add, disabled: !name.trim() }, /* @__PURE__ */ import_react.default.createElement(import_icons_material.Add, { fontSize: "small" }))))));
+  };
+  var HeaderEditor_default = HeaderEditor;
+
+  // src/front/SecretField.tsx
+  var import_react2 = __toESM(require_react(), 1);
+  var import_material2 = __toESM(require_material(), 1);
+  var import_icons_material2 = __toESM(require_icons_material(), 1);
+  var SecretField = ({ label, value, onChange, width }) => {
+    const [visible, setVisible] = (0, import_react2.useState)(false);
+    return /* @__PURE__ */ import_react2.default.createElement(
+      import_material2.TextField,
+      {
+        size: "small",
+        label,
+        value: value ?? "",
+        sx: { width: width ?? 260 },
+        type: visible ? "text" : "password",
+        onChange: (e) => onChange(e.target.value),
+        slotProps: {
+          input: {
+            endAdornment: /* @__PURE__ */ import_react2.default.createElement(import_material2.InputAdornment, { position: "end" }, /* @__PURE__ */ import_react2.default.createElement(import_material2.Tooltip, { title: visible ? "Hide" : "Show" }, /* @__PURE__ */ import_react2.default.createElement(import_material2.IconButton, { size: "small", edge: "end", onClick: () => setVisible(!visible) }, visible ? /* @__PURE__ */ import_react2.default.createElement(import_icons_material2.VisibilityOff, { fontSize: "small" }) : /* @__PURE__ */ import_react2.default.createElement(import_icons_material2.Visibility, { fontSize: "small" }))))
+          }
+        }
+      }
+    );
+  };
+  var SecretField_default = SecretField;
+
+  // src/front/HttpPullPushConfigDialog.tsx
+  var CONFIG_URL = (backendUrl) => `${backendUrl}/core/providerconfig/http-pull-push/configs`;
+  var TEST_URL = (backendUrl) => `${backendUrl}/core/providerconfig/http-pull-push/test`;
+  var EXPORT_VERSION = 1;
+  var METHODS_WITH_BODY = ["POST" /* POST */, "PUT" /* PUT */, "PATCH" /* PATCH */];
+  var authHeaders = (accessString) => ({
+    Authorization: accessString ? `Bearer ${accessString}` : "",
+    "Content-Type": "application/json",
+    "X-Kwirth-App": "true"
+  });
+  var stripCredentials = (config) => ({
+    ...config,
+    auth: {
+      ...config.auth,
+      password: void 0,
+      token: void 0,
+      headerValue: void 0
+    }
+  });
+  var HttpPullPushConfigDialog = ({ onClose, backendUrl, accessString }) => {
+    const [configs, setConfigs] = (0, import_react3.useState)([]);
+    const [loading, setLoading] = (0, import_react3.useState)(true);
+    const [saving, setSaving] = (0, import_react3.useState)(false);
+    const [deletingName, setDeletingName] = (0, import_react3.useState)();
+    const [error, setError] = (0, import_react3.useState)();
+    const [errors, setErrors] = (0, import_react3.useState)([]);
+    const [showForm, setShowForm] = (0, import_react3.useState)(false);
+    const [editingName, setEditingName] = (0, import_react3.useState)();
+    const [form, setForm] = (0, import_react3.useState)(newHttpPullConfig(""));
+    const [testing, setTesting] = (0, import_react3.useState)(false);
+    const [testResult, setTestResult] = (0, import_react3.useState)();
+    const [exportOpen, setExportOpen] = (0, import_react3.useState)(false);
+    const [exportSelected, setExportSelected] = (0, import_react3.useState)(/* @__PURE__ */ new Set());
+    const [exportWithCredentials, setExportWithCredentials] = (0, import_react3.useState)(false);
+    const [importData, setImportData] = (0, import_react3.useState)();
+    const [importSelected, setImportSelected] = (0, import_react3.useState)(/* @__PURE__ */ new Set());
+    const importFileRef = (0, import_react3.useRef)(null);
+    (0, import_react3.useEffect)(() => {
+      fetch(CONFIG_URL(backendUrl), { headers: { Authorization: accessString ? `Bearer ${accessString}` : "", "X-Kwirth-App": "true" } }).then((r) => r.ok ? r.json() : Promise.reject(`HTTP ${r.status}`)).then((data) => setConfigs(Array.isArray(data) ? data : [])).catch((err) => setError(`Failed to load connections: ${err}`)).finally(() => setLoading(false));
+    }, []);
+    const persist = async (next) => {
+      const found = validateConfigs(next);
+      setErrors(found);
+      if (found.length > 0) return false;
+      setSaving(true);
+      setError(void 0);
+      try {
+        const res = await fetch(CONFIG_URL(backendUrl), {
+          method: "PUT",
+          headers: authHeaders(accessString),
+          body: JSON.stringify(next)
+        });
+        if (!res.ok) {
+          const payload = await res.json().catch(() => void 0);
+          if (payload?.errors) {
+            setErrors(payload.errors);
+            return false;
+          }
+          throw new Error(`HTTP ${res.status}`);
+        }
+        setConfigs(next);
+        return true;
+      } catch (err) {
+        setError(`Failed to save: ${err}`);
+        return false;
+      } finally {
+        setSaving(false);
+      }
+    };
+    const freeName = (base) => {
+      const used = new Set(configs.map((c) => c.name));
+      if (!used.has(base)) return base;
+      let index = 2;
+      while (used.has(`${base}-${index}`)) index++;
+      return `${base}-${index}`;
+    };
+    const startNew = () => {
+      setForm(newHttpPullConfig(freeName("connection")));
+      setEditingName(void 0);
+      setErrors([]);
+      setShowForm(true);
+    };
+    const startEdit = (config) => {
+      setForm({ ...config });
+      setEditingName(config.name);
+      setErrors([]);
+      setShowForm(true);
+    };
+    const startClone = () => {
+      setForm((prev) => ({ ...prev, name: freeName(`${prev.name}-copy`) }));
+      setEditingName(void 0);
+      setErrors([]);
+      setShowForm(true);
+    };
+    const submitForm = async () => {
+      const next = editingName ? configs.map((c) => c.name === editingName ? form : c) : [...configs, form];
+      if (await persist(next)) {
+        setShowForm(false);
+        setEditingName(void 0);
+      }
+    };
+    const removeConnection = async (name) => {
+      setDeletingName(name);
+      const ok = await persist(configs.filter((c) => c.name !== name));
+      setDeletingName(void 0);
+      if (ok && editingName === name) {
+        setShowForm(false);
+        setEditingName(void 0);
+      }
+    };
+    const patch = (changes) => {
+      setForm((prev) => ({ ...prev, ...changes }));
+      setTestResult(void 0);
+    };
+    const patchAuth = (changes) => {
+      setForm((prev) => ({ ...prev, auth: { ...prev.auth, ...changes } }));
+      setTestResult(void 0);
+    };
+    const testConnection = async () => {
+      setTesting(true);
+      setTestResult(void 0);
+      setError(void 0);
+      try {
+        const res = await fetch(TEST_URL(backendUrl), {
+          method: "POST",
+          headers: authHeaders(accessString),
+          body: JSON.stringify(form)
+        });
+        if (!res.ok) throw new Error(`HTTP ${res.status}`);
+        setTestResult(await res.json());
+      } catch (err) {
+        setError(`Could not run the test: ${err}`);
+      } finally {
+        setTesting(false);
+      }
+    };
+    const doExport = () => {
+      const chosen = configs.filter((c) => exportSelected.has(c.name));
+      const payload = {
+        provider: "http-pull-push",
+        version: EXPORT_VERSION,
+        credentialsIncluded: exportWithCredentials,
+        configs: exportWithCredentials ? chosen : chosen.map(stripCredentials)
+      };
+      const blob = new Blob([JSON.stringify(payload, null, 2)], { type: "application/json" });
+      const url = URL.createObjectURL(blob);
+      const link = document.createElement("a");
+      link.href = url;
+      link.download = "http-pull-push-connections.json";
+      link.click();
+      URL.revokeObjectURL(url);
+      setExportOpen(false);
+    };
+    const openImport = (file) => {
+      const reader = new FileReader();
+      reader.onload = () => {
+        try {
+          const parsed = JSON.parse(String(reader.result));
+          if (!Array.isArray(parsed?.configs)) throw new Error("no connections in the file");
+          if (parsed.provider && parsed.provider !== "http-pull-push") throw new Error(`the file belongs to provider '${parsed.provider}'`);
+          setImportData(parsed);
+          setImportSelected(new Set(parsed.configs.map((c) => c.name)));
+        } catch (err) {
+          setError(`Invalid import file: ${err}`);
+        }
+      };
+      reader.readAsText(file);
+      if (importFileRef.current) importFileRef.current.value = "";
+    };
+    const doImport = async () => {
+      if (!importData) return;
+      const chosen = importData.configs.filter((c) => importSelected.has(c.name));
+      const byName = new Map(configs.map((c) => [c.name, c]));
+      for (const config of chosen) byName.set(config.name, { ...newHttpPullConfig(config.name), ...config });
+      if (await persist([...byName.values()])) setImportData(void 0);
+    };
+    const showBody = METHODS_WITH_BODY.includes(form.method);
+    const isHttps = (form.url ?? "").toLowerCase().startsWith("https://");
+    const importReplacing = importData ? importData.configs.filter((c) => importSelected.has(c.name) && configs.some((existing) => existing.name === c.name)).length : 0;
+    return /* @__PURE__ */ import_react3.default.createElement(import_react3.default.Fragment, null, /* @__PURE__ */ import_react3.default.createElement(import_material3.Dialog, { open: true, maxWidth: false, sx: { "& .MuiDialog-paper": { width: "1000px", height: "700px" } } }, /* @__PURE__ */ import_react3.default.createElement(import_material3.DialogTitle, null, "HTTP Pull-Push Provider \u2014 Connections"), /* @__PURE__ */ import_react3.default.createElement(import_material3.DialogContent, { sx: { pt: "16px !important", display: "flex", gap: 2, overflow: "hidden" } }, loading ? /* @__PURE__ */ import_react3.default.createElement(import_material3.Box, { sx: { display: "flex", justifyContent: "center", width: "100%", mt: 4 } }, /* @__PURE__ */ import_react3.default.createElement(import_material3.CircularProgress, null)) : /* @__PURE__ */ import_react3.default.createElement(import_react3.default.Fragment, null, /* @__PURE__ */ import_react3.default.createElement(import_material3.Box, { sx: { width: 260, flexShrink: 0, display: "flex", flexDirection: "column", gap: 1 } }, /* @__PURE__ */ import_react3.default.createElement(import_material3.Typography, { variant: "caption", color: "text.secondary", fontWeight: "bold" }, "Connections"), /* @__PURE__ */ import_react3.default.createElement(import_material3.Box, { sx: { flex: 1, border: 1, borderColor: "divider", borderRadius: 1, overflowY: "auto" } }, configs.length === 0 ? /* @__PURE__ */ import_react3.default.createElement(import_material3.Typography, { variant: "caption", color: "text.disabled", sx: { p: 1, display: "block" } }, "No connections yet.") : configs.map((config) => /* @__PURE__ */ import_react3.default.createElement(import_material3.Box, { key: config.name, sx: {
+      display: "flex",
+      alignItems: "center",
+      px: 1,
+      py: 0.5,
+      borderBottom: 1,
+      borderColor: "divider",
+      borderLeft: editingName === config.name ? 3 : 0,
+      borderLeftColor: "primary.main",
+      bgcolor: editingName === config.name ? "action.selected" : "transparent",
+      opacity: config.enabled ? 1 : 0.55
+    } }, /* @__PURE__ */ import_react3.default.createElement(import_material3.Box, { sx: { flex: 1, minWidth: 0, overflow: "hidden", cursor: "pointer" }, onClick: () => startEdit(config) }, /* @__PURE__ */ import_react3.default.createElement(import_material3.Typography, { variant: "body2", fontWeight: "bold", noWrap: true }, config.name), /* @__PURE__ */ import_react3.default.createElement(import_material3.Typography, { variant: "caption", color: "text.secondary", noWrap: true, display: "block" }, config.url || "\u2014")), /* @__PURE__ */ import_react3.default.createElement(
+      import_material3.Chip,
+      {
+        size: "small",
+        label: config.enabled ? "on" : "off",
+        color: config.enabled ? "success" : "default",
+        sx: { mr: 0.5 }
+      }
+    ), /* @__PURE__ */ import_react3.default.createElement(import_material3.Tooltip, { title: "Delete" }, /* @__PURE__ */ import_react3.default.createElement("span", null, /* @__PURE__ */ import_react3.default.createElement(
+      import_material3.IconButton,
+      {
+        size: "small",
+        color: "error",
+        "aria-label": `Delete ${config.name}`,
+        disabled: deletingName === config.name || saving,
+        onClick: () => removeConnection(config.name)
+      },
+      deletingName === config.name ? /* @__PURE__ */ import_react3.default.createElement(import_material3.CircularProgress, { size: 12 }) : /* @__PURE__ */ import_react3.default.createElement(import_icons_material3.Delete, { sx: { fontSize: 14 } })
+    )))))), /* @__PURE__ */ import_react3.default.createElement(import_material3.Stack, { direction: "row", spacing: 0.5 }, /* @__PURE__ */ import_react3.default.createElement(import_material3.Button, { size: "small", startIcon: /* @__PURE__ */ import_react3.default.createElement(import_icons_material3.Add, null), onClick: startNew, sx: { flex: 1 } }, "New"), /* @__PURE__ */ import_react3.default.createElement(import_material3.Button, { size: "small", startIcon: /* @__PURE__ */ import_react3.default.createElement(import_icons_material3.ContentCopy, null), disabled: !showForm, onClick: startClone, sx: { flex: 1 } }, "Clone"))), /* @__PURE__ */ import_react3.default.createElement(import_material3.Divider, { orientation: "vertical", flexItem: true }), /* @__PURE__ */ import_react3.default.createElement(import_material3.Box, { sx: { flex: 1, minWidth: 0, display: "flex", flexDirection: "column", gap: 1.5, overflow: "hidden" } }, !showForm ? /* @__PURE__ */ import_react3.default.createElement(import_material3.Box, { sx: { m: "auto", color: "text.disabled" } }, /* @__PURE__ */ import_react3.default.createElement(import_material3.Typography, { variant: "body2" }, "Select a connection to edit or click New.")) : /* @__PURE__ */ import_react3.default.createElement(import_react3.default.Fragment, null, /* @__PURE__ */ import_react3.default.createElement(import_material3.Typography, { variant: "caption", color: "text.secondary", fontWeight: "bold" }, editingName ? `Editing: ${editingName}` : "New connection"), /* @__PURE__ */ import_react3.default.createElement(import_material3.Box, { sx: { flex: 1, overflowY: "auto", pr: 1, pt: 1 } }, /* @__PURE__ */ import_react3.default.createElement(import_material3.Stack, { spacing: 2 }, /* @__PURE__ */ import_react3.default.createElement(import_material3.Stack, { direction: "row", spacing: 2, alignItems: "center" }, /* @__PURE__ */ import_react3.default.createElement(
+      import_material3.TextField,
+      {
+        size: "small",
+        label: "Connection name",
+        value: form.name,
+        sx: { width: 220 },
+        onChange: (e) => patch({ name: e.target.value })
+      }
+    ), /* @__PURE__ */ import_react3.default.createElement(import_material3.FormControlLabel, { label: "Enabled", control: /* @__PURE__ */ import_react3.default.createElement(import_material3.Switch, { checked: form.enabled, onChange: (_e, checked) => patch({ enabled: checked }) }) })), !form.enabled && /* @__PURE__ */ import_react3.default.createElement(import_material3.Alert, { severity: "info" }, "This connection is stored but not operative: it is not polled and delivers nothing."), /* @__PURE__ */ import_react3.default.createElement(import_material3.Stack, { direction: "row", spacing: 2 }, /* @__PURE__ */ import_react3.default.createElement(import_material3.FormControl, { size: "small", sx: { width: 120 } }, /* @__PURE__ */ import_react3.default.createElement(import_material3.InputLabel, null, "Method"), /* @__PURE__ */ import_react3.default.createElement(
+      import_material3.Select,
+      {
+        label: "Method",
+        value: form.method,
+        onChange: (e) => patch({ method: e.target.value })
+      },
+      Object.values(EHttpMethod).map((m) => /* @__PURE__ */ import_react3.default.createElement(import_material3.MenuItem, { key: m, value: m }, m))
+    )), /* @__PURE__ */ import_react3.default.createElement(
+      import_material3.TextField,
+      {
+        size: "small",
+        label: "URL",
+        value: form.url,
+        sx: { flex: 1 },
+        placeholder: "https://api.example.com/quotes",
+        onChange: (e) => patch({ url: e.target.value })
+      }
+    )), /* @__PURE__ */ import_react3.default.createElement(import_material3.Stack, { direction: "row", spacing: 2 }, /* @__PURE__ */ import_react3.default.createElement(
+      import_material3.TextField,
+      {
+        size: "small",
+        label: "Interval (s)",
+        type: "number",
+        sx: { width: 130 },
+        value: form.intervalSeconds,
+        onChange: (e) => patch({ intervalSeconds: parseInt(e.target.value, 10) || 0 }),
+        slotProps: { htmlInput: { min: 1 } }
+      }
+    ), /* @__PURE__ */ import_react3.default.createElement(
+      import_material3.TextField,
+      {
+        size: "small",
+        label: "Timeout (ms)",
+        type: "number",
+        sx: { width: 140 },
+        value: form.timeoutMs,
+        onChange: (e) => patch({ timeoutMs: parseInt(e.target.value, 10) || 0 }),
+        slotProps: { htmlInput: { min: 1 } }
+      }
+    ), /* @__PURE__ */ import_react3.default.createElement(
+      import_material3.TextField,
+      {
+        size: "small",
+        label: "Retries",
+        type: "number",
+        sx: { width: 110 },
+        value: form.retries,
+        onChange: (e) => patch({ retries: parseInt(e.target.value, 10) || 0 }),
+        slotProps: { htmlInput: { min: 0 } }
+      }
+    )), /* @__PURE__ */ import_react3.default.createElement(import_material3.Stack, { direction: "row", spacing: 2, alignItems: "center", flexWrap: "wrap", useFlexGap: true }, /* @__PURE__ */ import_react3.default.createElement(import_material3.FormControl, { size: "small", sx: { width: 160 } }, /* @__PURE__ */ import_react3.default.createElement(import_material3.InputLabel, null, "Response"), /* @__PURE__ */ import_react3.default.createElement(
+      import_material3.Select,
+      {
+        label: "Response",
+        value: form.responseType,
+        onChange: (e) => patch({ responseType: e.target.value })
+      },
+      /* @__PURE__ */ import_react3.default.createElement(import_material3.MenuItem, { value: "json" /* JSON */ }, "JSON (parsed)"),
+      /* @__PURE__ */ import_react3.default.createElement(import_material3.MenuItem, { value: "text" /* TEXT */ }, "Text (raw)")
+    )), /* @__PURE__ */ import_react3.default.createElement(import_material3.FormControl, { size: "small", sx: { width: 200 } }, /* @__PURE__ */ import_react3.default.createElement(import_material3.InputLabel, null, "Emit"), /* @__PURE__ */ import_react3.default.createElement(
+      import_material3.Select,
+      {
+        label: "Emit",
+        value: form.emitMode,
+        onChange: (e) => patch({ emitMode: e.target.value })
+      },
+      /* @__PURE__ */ import_react3.default.createElement(import_material3.MenuItem, { value: "always" /* ALWAYS */ }, "Always"),
+      /* @__PURE__ */ import_react3.default.createElement(import_material3.MenuItem, { value: "onChange" /* ON_CHANGE */ }, "Only when it changes")
+    )), /* @__PURE__ */ import_react3.default.createElement(import_material3.FormControlLabel, { label: "Accept self-signed certificates", control: /* @__PURE__ */ import_react3.default.createElement(
+      import_material3.Switch,
+      {
+        checked: form.allowInsecureTls,
+        disabled: !isHttps,
+        onChange: (_e, checked) => patch({ allowInsecureTls: checked })
+      }
+    ) })), /* @__PURE__ */ import_react3.default.createElement(import_material3.Divider, null), /* @__PURE__ */ import_react3.default.createElement(import_material3.Stack, { direction: "row", spacing: 2, alignItems: "center", flexWrap: "wrap", useFlexGap: true }, /* @__PURE__ */ import_react3.default.createElement(import_material3.FormControl, { size: "small", sx: { width: 160 } }, /* @__PURE__ */ import_react3.default.createElement(import_material3.InputLabel, null, "Auth"), /* @__PURE__ */ import_react3.default.createElement(
+      import_material3.Select,
+      {
+        label: "Auth",
+        value: form.auth.type,
+        onChange: (e) => patchAuth({ type: e.target.value })
+      },
+      /* @__PURE__ */ import_react3.default.createElement(import_material3.MenuItem, { value: "none" /* NONE */ }, "None"),
+      /* @__PURE__ */ import_react3.default.createElement(import_material3.MenuItem, { value: "basic" /* BASIC */ }, "Basic"),
+      /* @__PURE__ */ import_react3.default.createElement(import_material3.MenuItem, { value: "bearer" /* BEARER */ }, "Bearer token"),
+      /* @__PURE__ */ import_react3.default.createElement(import_material3.MenuItem, { value: "header" /* HEADER */ }, "Custom header")
+    )), form.auth.type === "basic" /* BASIC */ && /* @__PURE__ */ import_react3.default.createElement(import_react3.default.Fragment, null, /* @__PURE__ */ import_react3.default.createElement(
+      import_material3.TextField,
+      {
+        size: "small",
+        label: "Username",
+        value: form.auth.username ?? "",
+        sx: { width: 200 },
+        onChange: (e) => patchAuth({ username: e.target.value })
+      }
+    ), /* @__PURE__ */ import_react3.default.createElement(
+      SecretField_default,
+      {
+        label: "Password",
+        value: form.auth.password ?? "",
+        onChange: (v) => patchAuth({ password: v })
+      }
+    )), form.auth.type === "bearer" /* BEARER */ && /* @__PURE__ */ import_react3.default.createElement(
+      SecretField_default,
+      {
+        label: "Token",
+        value: form.auth.token ?? "",
+        width: 360,
+        onChange: (v) => patchAuth({ token: v })
+      }
+    ), form.auth.type === "header" /* HEADER */ && /* @__PURE__ */ import_react3.default.createElement(import_react3.default.Fragment, null, /* @__PURE__ */ import_react3.default.createElement(
+      import_material3.TextField,
+      {
+        size: "small",
+        label: "Header name",
+        value: form.auth.headerName ?? "",
+        sx: { width: 200 },
+        onChange: (e) => patchAuth({ headerName: e.target.value })
+      }
+    ), /* @__PURE__ */ import_react3.default.createElement(
+      SecretField_default,
+      {
+        label: "Header value",
+        value: form.auth.headerValue ?? "",
+        onChange: (v) => patchAuth({ headerValue: v })
+      }
+    ))), /* @__PURE__ */ import_react3.default.createElement(import_material3.Divider, null), /* @__PURE__ */ import_react3.default.createElement(HeaderEditor_default, { headers: form.headers, onChange: (h) => patch({ headers: h }) }), showBody && /* @__PURE__ */ import_react3.default.createElement(
+      import_material3.TextField,
+      {
+        size: "small",
+        label: "Body",
+        multiline: true,
+        minRows: 3,
+        value: form.body ?? "",
+        onChange: (e) => patch({ body: e.target.value })
+      }
+    ))), errors.length > 0 && /* @__PURE__ */ import_react3.default.createElement(import_material3.Alert, { severity: "warning", sx: { py: 0 } }, errors.map((e, i) => /* @__PURE__ */ import_react3.default.createElement("div", { key: i }, e))), error && /* @__PURE__ */ import_react3.default.createElement(import_material3.Alert, { severity: "error", sx: { py: 0 } }, error), testResult && /* @__PURE__ */ import_react3.default.createElement(import_material3.Alert, { severity: testResult.ok ? testResult.status && testResult.status < 400 ? "success" : "warning" : "error", sx: { py: 0 } }, testResult.ok ? /* @__PURE__ */ import_react3.default.createElement(import_react3.default.Fragment, null, /* @__PURE__ */ import_react3.default.createElement(import_material3.Typography, { variant: "body2" }, "HTTP ", testResult.status, " \xB7 ", testResult.durationMs, " ms \xB7 ", testResult.bytes, " bytes", form.responseType === "json" /* JSON */ && testResult.jsonParsed === false && " \xB7 body is not valid JSON"), testResult.preview && /* @__PURE__ */ import_react3.default.createElement(import_material3.Box, { component: "pre", sx: { m: 0, mt: 0.5, maxHeight: 120, overflow: "auto", fontSize: 11, whiteSpace: "pre-wrap", wordBreak: "break-all" } }, testResult.preview)) : /* @__PURE__ */ import_react3.default.createElement(import_material3.Typography, { variant: "body2" }, testResult.error, " (", testResult.durationMs, " ms)")), /* @__PURE__ */ import_react3.default.createElement(import_material3.Stack, { direction: "row", justifyContent: "flex-end", spacing: 1 }, /* @__PURE__ */ import_react3.default.createElement(import_material3.Tooltip, { title: "Run the request now, from the Kwirth backend \u2014 the same network, certificates and identity the real polling uses" }, /* @__PURE__ */ import_react3.default.createElement("span", null, /* @__PURE__ */ import_react3.default.createElement(import_material3.Button, { size: "small", disabled: testing || saving, onClick: testConnection }, testing ? /* @__PURE__ */ import_react3.default.createElement(import_material3.CircularProgress, { size: 14 }) : "Test"))), /* @__PURE__ */ import_react3.default.createElement(import_material3.Button, { size: "small", variant: "contained", disabled: saving || testing, onClick: submitForm }, saving ? /* @__PURE__ */ import_react3.default.createElement(import_material3.CircularProgress, { size: 14 }) : editingName ? "Update" : "Add"), /* @__PURE__ */ import_react3.default.createElement(import_material3.Button, { size: "small", disabled: saving, onClick: () => {
+      setShowForm(false);
+      setEditingName(void 0);
+      setErrors([]);
+      setTestResult(void 0);
+    } }, "Cancel")))))), /* @__PURE__ */ import_react3.default.createElement(import_material3.DialogActions, { sx: { justifyContent: "space-between", px: 2 } }, /* @__PURE__ */ import_react3.default.createElement(import_material3.Stack, { direction: "row", spacing: 1 }, /* @__PURE__ */ import_react3.default.createElement(
+      "input",
+      {
+        ref: importFileRef,
+        type: "file",
+        accept: ".json",
+        style: { display: "none" },
+        onChange: (e) => {
+          const f = e.target.files?.[0];
+          if (f) openImport(f);
+        }
+      }
+    ), /* @__PURE__ */ import_react3.default.createElement(import_material3.Tooltip, { title: "Export connections to JSON" }, /* @__PURE__ */ import_react3.default.createElement("span", null, /* @__PURE__ */ import_react3.default.createElement(
+      import_material3.Button,
+      {
+        size: "small",
+        startIcon: /* @__PURE__ */ import_react3.default.createElement(import_icons_material3.FileDownload, null),
+        disabled: configs.length === 0,
+        onClick: () => {
+          setExportSelected(new Set(configs.map((c) => c.name)));
+          setExportWithCredentials(false);
+          setExportOpen(true);
+        }
+      },
+      "Export"
+    ))), /* @__PURE__ */ import_react3.default.createElement(import_material3.Tooltip, { title: "Import connections from JSON" }, /* @__PURE__ */ import_react3.default.createElement(import_material3.Button, { size: "small", startIcon: /* @__PURE__ */ import_react3.default.createElement(import_icons_material3.FileUpload, null), onClick: () => importFileRef.current?.click() }, "Import"))), /* @__PURE__ */ import_react3.default.createElement(import_material3.Button, { onClick: onClose, disabled: saving }, "Close"))), /* @__PURE__ */ import_react3.default.createElement(import_material3.Dialog, { open: exportOpen, maxWidth: false, sx: { "& .MuiDialog-paper": { width: "480px" } } }, /* @__PURE__ */ import_react3.default.createElement(import_material3.DialogTitle, null, "Export connections"), /* @__PURE__ */ import_react3.default.createElement(import_material3.DialogContent, { sx: { pt: "16px !important" } }, /* @__PURE__ */ import_react3.default.createElement(import_material3.Stack, { spacing: 1 }, /* @__PURE__ */ import_react3.default.createElement(
+      import_material3.FormControlLabel,
+      {
+        label: "Select all",
+        control: /* @__PURE__ */ import_react3.default.createElement(
+          import_material3.Checkbox,
+          {
+            checked: exportSelected.size === configs.length && configs.length > 0,
+            indeterminate: exportSelected.size > 0 && exportSelected.size < configs.length,
+            onChange: (_e, checked) => setExportSelected(checked ? new Set(configs.map((c) => c.name)) : /* @__PURE__ */ new Set())
+          }
+        )
+      }
+    ), /* @__PURE__ */ import_react3.default.createElement(import_material3.Box, { sx: { maxHeight: 220, overflowY: "auto", border: 1, borderColor: "divider", borderRadius: 1, px: 1 } }, configs.map((config) => /* @__PURE__ */ import_react3.default.createElement(
+      import_material3.FormControlLabel,
+      {
+        key: config.name,
+        label: config.name,
+        sx: { display: "block" },
+        control: /* @__PURE__ */ import_react3.default.createElement(
+          import_material3.Checkbox,
+          {
+            checked: exportSelected.has(config.name),
+            onChange: (_e, checked) => setExportSelected((prev) => {
+              const next = new Set(prev);
+              if (checked) next.add(config.name);
+              else next.delete(config.name);
+              return next;
+            })
+          }
+        )
+      }
+    ))), /* @__PURE__ */ import_react3.default.createElement(
+      import_material3.FormControlLabel,
+      {
+        label: "Include credentials",
+        control: /* @__PURE__ */ import_react3.default.createElement(import_material3.Checkbox, { checked: exportWithCredentials, onChange: (_e, checked) => setExportWithCredentials(checked) })
+      }
+    ), exportWithCredentials ? /* @__PURE__ */ import_react3.default.createElement(import_material3.Alert, { severity: "warning" }, "Passwords, tokens and header values will be written to the file in clear text. Treat it as a secret.") : /* @__PURE__ */ import_react3.default.createElement(import_material3.Alert, { severity: "info" }, "Credentials are left empty. Whoever imports the file will have to type them again."))), /* @__PURE__ */ import_react3.default.createElement(import_material3.DialogActions, null, /* @__PURE__ */ import_react3.default.createElement(import_material3.Button, { variant: "contained", disabled: exportSelected.size === 0, onClick: doExport }, "Export"), /* @__PURE__ */ import_react3.default.createElement(import_material3.Button, { onClick: () => setExportOpen(false) }, "Cancel"))), /* @__PURE__ */ import_react3.default.createElement(import_material3.Dialog, { open: importData !== void 0, maxWidth: false, sx: { "& .MuiDialog-paper": { width: "480px" } } }, /* @__PURE__ */ import_react3.default.createElement(import_material3.DialogTitle, null, "Import connections"), /* @__PURE__ */ import_react3.default.createElement(import_material3.DialogContent, { sx: { pt: "16px !important" } }, /* @__PURE__ */ import_react3.default.createElement(import_material3.Stack, { spacing: 1 }, importData?.configs.length === 0 ? /* @__PURE__ */ import_react3.default.createElement(import_material3.Typography, { variant: "body2", color: "text.secondary" }, "The file has no connections.") : /* @__PURE__ */ import_react3.default.createElement(import_react3.default.Fragment, null, /* @__PURE__ */ import_react3.default.createElement(
+      import_material3.FormControlLabel,
+      {
+        label: "Select all",
+        control: /* @__PURE__ */ import_react3.default.createElement(
+          import_material3.Checkbox,
+          {
+            checked: importSelected.size === (importData?.configs.length ?? 0) && (importData?.configs.length ?? 0) > 0,
+            indeterminate: importSelected.size > 0 && importSelected.size < (importData?.configs.length ?? 0),
+            onChange: (_e, checked) => setImportSelected(checked ? new Set(importData?.configs.map((c) => c.name) ?? []) : /* @__PURE__ */ new Set())
+          }
+        )
+      }
+    ), /* @__PURE__ */ import_react3.default.createElement(import_material3.Box, { sx: { maxHeight: 220, overflowY: "auto", border: 1, borderColor: "divider", borderRadius: 1, px: 1 } }, importData?.configs.map((config) => /* @__PURE__ */ import_react3.default.createElement(
+      import_material3.FormControlLabel,
+      {
+        key: config.name,
+        sx: { display: "block" },
+        label: /* @__PURE__ */ import_react3.default.createElement(import_react3.default.Fragment, null, config.name, configs.some((c) => c.name === config.name) && /* @__PURE__ */ import_react3.default.createElement(import_material3.Chip, { size: "small", label: "replaces", color: "warning", variant: "outlined", sx: { ml: 1 } })),
+        control: /* @__PURE__ */ import_react3.default.createElement(
+          import_material3.Checkbox,
+          {
+            checked: importSelected.has(config.name),
+            onChange: (_e, checked) => setImportSelected((prev) => {
+              const next = new Set(prev);
+              if (checked) next.add(config.name);
+              else next.delete(config.name);
+              return next;
+            })
+          }
+        )
+      }
+    ))), importReplacing > 0 && /* @__PURE__ */ import_react3.default.createElement(import_material3.Alert, { severity: "warning" }, importReplacing, " existing connection(s) will be replaced."), importData?.credentialsIncluded === false && /* @__PURE__ */ import_react3.default.createElement(import_material3.Alert, { severity: "info" }, "The file carries no credentials: you will have to type them after importing.")), errors.length > 0 && /* @__PURE__ */ import_react3.default.createElement(import_material3.Alert, { severity: "warning" }, errors.map((e, i) => /* @__PURE__ */ import_react3.default.createElement("div", { key: i }, e))))), /* @__PURE__ */ import_react3.default.createElement(import_material3.DialogActions, null, /* @__PURE__ */ import_react3.default.createElement(import_material3.Button, { variant: "contained", disabled: importSelected.size === 0 || saving, onClick: doImport }, "Import"), /* @__PURE__ */ import_react3.default.createElement(import_material3.Button, { onClick: () => {
+      setImportData(void 0);
+      setErrors([]);
+    } }, "Cancel"))));
+  };
+  var HttpPullPushConfigDialog_default = HttpPullPushConfigDialog;
+
+  // src/front/index.tsx
+  window.__kwirth_providers__ = window.__kwirth_providers__ ?? {};
+  window.__kwirth_providers__["http-pull-push"] = { ConfigDialog: HttpPullPushConfigDialog_default };
+})();

package/package.json

@@ -0,0 +1,12 @@
+{
+  "type": "commonjs",
+  "extensionType": "provider",
+  "id": "http-pull-push",
+  "name": "@kwirthmagnify/kwirth-provider-http-pull-push",
+  "displayName": "HTTP Pull-Push Provider",
+  "version": "0.1.0",
+  "description": "HTTP polling provider for Kwirth — pulls remote HTTP endpoints on a schedule and pushes each result to the subscribed channels",
+  "website": "https://kwirthmagnify.dev",
+  "requiresRestart": false,
+  "requiresExtension": []
+}