@botpress/adk-cli 1.2.1 → 1.4.0

package/dist/bp-cli/dist/utils/require-utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/bp-cli/dist/utils/require-utils.test.js

@@ -0,0 +1,54 @@
+"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 __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 import_vitest = require("vitest");
+var requireUtils = __toESM(require("./require-utils"));
+(0, import_vitest.test)("require js code should do as its name suggests", () => {
+  const code = `
+    module.exports = {
+      foo: 'bar'
+    }
+  `;
+  const result = requireUtils.requireJsCode(code);
+  (0, import_vitest.expect)(result.foo).toBe("bar");
+});
+const getError = (fn) => {
+  try {
+    fn();
+    return;
+  } catch (thrown) {
+    return thrown instanceof Error ? thrown : new Error(`${thrown}`);
+  }
+};
+(0, import_vitest.test)("require js code should indicate issue in stack trace", () => {
+  const code = `
+    var foo = undefined
+    module.exports = {
+      bar: foo.bar
+    }
+  `;
+  const error = getError(() => requireUtils.requireJsCode(code));
+  (0, import_vitest.expect)(error).toBeDefined();
+  (0, import_vitest.expect)(error?.message).toContain("bar: foo.bar");
+});
+//# sourceMappingURL=require-utils.test.js.map

package/dist/bp-cli/dist/utils/require-utils.test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/require-utils.test.ts"],
+  "sourcesContent": ["import { test, expect } from 'vitest'\nimport * as requireUtils from './require-utils'\n\ntest('require js code should do as its name suggests', () => {\n  const code = `\n    module.exports = {\n      foo: 'bar'\n    }\n  `\n\n  const result = requireUtils.requireJsCode<{ foo: string }>(code)\n\n  expect(result.foo).toBe('bar')\n})\n\nconst getError = (fn: () => void): Error | undefined => {\n  try {\n    fn()\n    return\n  } catch (thrown: unknown) {\n    return thrown instanceof Error ? thrown : new Error(`${thrown}`)\n  }\n}\n\ntest('require js code should indicate issue in stack trace', () => {\n  const code = `\n    var foo = undefined\n    module.exports = {\n      bar: foo.bar\n    }\n  `\n\n  const error = getError(() => requireUtils.requireJsCode(code))\n\n  expect(error).toBeDefined()\n  expect(error?.message).toContain('bar: foo.bar')\n})\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAAA,oBAA6B;AAC7B,mBAA8B;AAAA,IAE9B,oBAAK,kDAAkD,MAAM;AAC3D,QAAM,OAAO;AAAA;AAAA;AAAA;AAAA;AAMb,QAAM,SAAS,aAAa,cAA+B,IAAI;AAE/D,4BAAO,OAAO,GAAG,EAAE,KAAK,KAAK;AAC/B,CAAC;AAED,MAAM,WAAW,CAAC,OAAsC;AACtD,MAAI;AACF,OAAG;AACH;AAAA,EACF,SAAS,QAAiB;AACxB,WAAO,kBAAkB,QAAQ,SAAS,IAAI,MAAM,GAAG,MAAM,EAAE;AAAA,EACjE;AACF;AAAA,IAEA,oBAAK,wDAAwD,MAAM;AACjE,QAAM,OAAO;AAAA;AAAA;AAAA;AAAA;AAAA;AAOb,QAAM,QAAQ,SAAS,MAAM,aAAa,cAAc,IAAI,CAAC;AAE7D,4BAAO,KAAK,EAAE,YAAY;AAC1B,4BAAO,OAAO,OAAO,EAAE,UAAU,cAAc;AACjD,CAAC;",
+  "names": []
+}

package/dist/bp-cli/dist/utils/schema-utils.d.ts

@@ -0,0 +1,16 @@
+import * as sdk from '@botpress/sdk';
+import { JSONSchema7 } from 'json-schema';
+type SchemaOptions = {
+    title?: string;
+    examples?: any[];
+};
+type SchemaDefinition = {
+    schema: sdk.ZuiObjectOrRefSchema;
+    ui?: Record<string, SchemaOptions | undefined>;
+};
+type MapSchemaOptions = {
+    useLegacyZuiTransformer?: boolean;
+};
+export declare function mapZodToJsonSchema(definition: SchemaDefinition, options: MapSchemaOptions): Promise<ReturnType<typeof sdk.transforms.toJSONSchemaLegacy>>;
+export declare const dereferenceSchema: (schema: JSONSchema7) => Promise<JSONSchema7>;
+export {};

package/dist/bp-cli/dist/utils/schema-utils.js

@@ -0,0 +1,79 @@
+"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);
+var schema_utils_exports = {};
+__export(schema_utils_exports, {
+  dereferenceSchema: () => dereferenceSchema,
+  mapZodToJsonSchema: () => mapZodToJsonSchema
+});
+module.exports = __toCommonJS(schema_utils_exports);
+var import_json_schema_ref_parser = require("@apidevtools/json-schema-ref-parser");
+var sdk = __toESM(require("@botpress/sdk"));
+const isObjectSchema = (schema) => schema.type === "object";
+async function mapZodToJsonSchema(definition, options) {
+  let schema;
+  if (options.useLegacyZuiTransformer) {
+    schema = sdk.transforms.toJSONSchemaLegacy(definition.schema, { target: "jsonSchema7" });
+  } else {
+    schema = sdk.transforms.toJSONSchema(definition.schema);
+  }
+  schema = await dereferenceSchema(schema);
+  if (!isObjectSchema(schema) || !definition.ui) {
+    return schema;
+  }
+  for (const [key, value] of Object.entries(definition.ui ?? {})) {
+    const property = schema.properties?.[key];
+    if (!property) {
+      continue;
+    }
+    if (!!value?.title) {
+      ;
+      property.title = value.title;
+    }
+    if (!!value?.examples) {
+      ;
+      property.examples = value.examples;
+    }
+  }
+  return schema;
+}
+const dereferenceSchema = async (schema) => {
+  return (0, import_json_schema_ref_parser.dereference)(schema, {
+    resolve: {
+      external: false,
+      file: false,
+      http: false
+    }
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  dereferenceSchema,
+  mapZodToJsonSchema
+});
+//# sourceMappingURL=schema-utils.js.map

package/dist/bp-cli/dist/utils/schema-utils.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/schema-utils.ts"],
+  "sourcesContent": ["import { dereference } from '@apidevtools/json-schema-ref-parser'\nimport * as sdk from '@botpress/sdk'\nimport { JSONSchema7 } from 'json-schema'\n\ntype ZuiToJsonSchema = typeof sdk.transforms.toJSONSchemaLegacy\ntype JsonSchema = ReturnType<ZuiToJsonSchema>\n\ntype SchemaOptions = {\n  title?: string\n  examples?: any[]\n}\n\ntype SchemaDefinition = {\n  schema: sdk.ZuiObjectOrRefSchema\n  ui?: Record<string, SchemaOptions | undefined>\n}\n\ntype MapSchemaOptions = {\n  useLegacyZuiTransformer?: boolean\n}\n\nconst isObjectSchema = (schema: JsonSchema): boolean => schema.type === 'object'\n\nexport async function mapZodToJsonSchema(\n  definition: SchemaDefinition,\n  options: MapSchemaOptions\n): Promise<ReturnType<typeof sdk.transforms.toJSONSchemaLegacy>> {\n  let schema: JSONSchema7\n  if (options.useLegacyZuiTransformer) {\n    schema = sdk.transforms.toJSONSchemaLegacy(definition.schema, { target: 'jsonSchema7' })\n  } else {\n    schema = sdk.transforms.toJSONSchema(definition.schema)\n  }\n  schema = (await dereferenceSchema(schema)) as typeof schema\n\n  if (!isObjectSchema(schema) || !definition.ui) {\n    return schema\n  }\n\n  for (const [key, value] of Object.entries(definition.ui ?? {})) {\n    const property = schema.properties?.[key]\n\n    if (!property) {\n      continue\n    }\n\n    if (!!value?.title) {\n      ;(property as any).title = value.title\n    }\n\n    if (!!value?.examples) {\n      ;(property as any).examples = value.examples\n    }\n  }\n\n  return schema\n}\n\nexport const dereferenceSchema = async (schema: JSONSchema7): Promise<JSONSchema7> => {\n  return dereference(schema, {\n    resolve: {\n      external: false,\n      file: false,\n      http: false,\n    },\n  })\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oCAA4B;AAC5B,UAAqB;AAoBrB,MAAM,iBAAiB,CAAC,WAAgC,OAAO,SAAS;AAExE,eAAsB,mBACpB,YACA,SAC+D;AAC/D,MAAI;AACJ,MAAI,QAAQ,yBAAyB;AACnC,aAAS,IAAI,WAAW,mBAAmB,WAAW,QAAQ,EAAE,QAAQ,cAAc,CAAC;AAAA,EACzF,OAAO;AACL,aAAS,IAAI,WAAW,aAAa,WAAW,MAAM;AAAA,EACxD;AACA,WAAU,MAAM,kBAAkB,MAAM;AAExC,MAAI,CAAC,eAAe,MAAM,KAAK,CAAC,WAAW,IAAI;AAC7C,WAAO;AAAA,EACT;AAEA,aAAW,CAAC,KAAK,KAAK,KAAK,OAAO,QAAQ,WAAW,MAAM,CAAC,CAAC,GAAG;AAC9D,UAAM,WAAW,OAAO,aAAa,GAAG;AAExC,QAAI,CAAC,UAAU;AACb;AAAA,IACF;AAEA,QAAI,CAAC,CAAC,OAAO,OAAO;AAClB;AAAC,MAAC,SAAiB,QAAQ,MAAM;AAAA,IACnC;AAEA,QAAI,CAAC,CAAC,OAAO,UAAU;AACrB;AAAC,MAAC,SAAiB,WAAW,MAAM;AAAA,IACtC;AAAA,EACF;AAEA,SAAO;AACT;AAEO,MAAM,oBAAoB,OAAO,WAA8C;AACpF,aAAO,2CAAY,QAAQ;AAAA,IACzB,SAAS;AAAA,MACP,UAAU;AAAA,MACV,MAAM;AAAA,MACN,MAAM;AAAA,IACR;AAAA,EACF,CAAC;AACH;",
+  "names": []
+}

package/dist/bp-cli/dist/utils/schema-utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/bp-cli/dist/utils/schema-utils.test.js

@@ -0,0 +1,50 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_schema_utils = require("./schema-utils");
+(0, import_vitest.describe)("dereferenceSchema", () => {
+  (0, import_vitest.it)("should do nothing if no $ref", async () => {
+    const schema = { type: "object" };
+    const result = await (0, import_schema_utils.dereferenceSchema)(schema);
+    (0, import_vitest.expect)(result).toEqual(schema);
+  });
+  (0, import_vitest.it)("should dereference local $ref", async () => {
+    const schema = {
+      type: "object",
+      properties: {
+        foo: { $ref: "#/$defs/foo" },
+        bar: { $ref: "#/definitions/bar" }
+      },
+      $defs: {
+        foo: { type: "string" }
+      },
+      definitions: {
+        bar: { type: "number" }
+      }
+    };
+    const result = await (0, import_schema_utils.dereferenceSchema)(schema);
+    (0, import_vitest.expect)(result).toEqual({
+      type: "object",
+      properties: {
+        foo: { type: "string" },
+        bar: { type: "number" }
+      },
+      $defs: {
+        foo: { type: "string" }
+      },
+      definitions: {
+        bar: { type: "number" }
+      }
+    });
+  });
+  (0, import_vitest.it)("should ignore non-local $ref", async () => {
+    const schema = {
+      type: "object",
+      properties: {
+        foo: { $ref: "TItem" }
+      }
+    };
+    const result = await (0, import_schema_utils.dereferenceSchema)(schema);
+    (0, import_vitest.expect)(result).toEqual(schema);
+  });
+});
+//# sourceMappingURL=schema-utils.test.js.map

package/dist/bp-cli/dist/utils/schema-utils.test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/schema-utils.test.ts"],
+  "sourcesContent": ["import { it, expect, describe } from 'vitest'\nimport { dereferenceSchema } from './schema-utils'\nimport { JSONSchema7 } from 'json-schema'\n\ndescribe('dereferenceSchema', () => {\n  it('should do nothing if no $ref', async () => {\n    const schema: JSONSchema7 = { type: 'object' }\n    const result = await dereferenceSchema(schema)\n    expect(result).toEqual(schema)\n  })\n\n  it('should dereference local $ref', async () => {\n    const schema: JSONSchema7 = {\n      type: 'object',\n      properties: {\n        foo: { $ref: '#/$defs/foo' },\n        bar: { $ref: '#/definitions/bar' },\n      },\n      $defs: {\n        foo: { type: 'string' },\n      },\n      definitions: {\n        bar: { type: 'number' },\n      },\n    }\n    const result = await dereferenceSchema(schema)\n    expect(result).toEqual({\n      type: 'object',\n      properties: {\n        foo: { type: 'string' },\n        bar: { type: 'number' },\n      },\n      $defs: {\n        foo: { type: 'string' },\n      },\n      definitions: {\n        bar: { type: 'number' },\n      },\n    })\n  })\n\n  it('should ignore non-local $ref', async () => {\n    const schema: JSONSchema7 = {\n      type: 'object',\n      properties: {\n        foo: { $ref: 'TItem' },\n      },\n    }\n    const result = await dereferenceSchema(schema)\n    expect(result).toEqual(schema)\n  })\n})\n"],
+  "mappings": ";AAAA,oBAAqC;AACrC,0BAAkC;AAAA,IAGlC,wBAAS,qBAAqB,MAAM;AAClC,wBAAG,gCAAgC,YAAY;AAC7C,UAAM,SAAsB,EAAE,MAAM,SAAS;AAC7C,UAAM,SAAS,UAAM,uCAAkB,MAAM;AAC7C,8BAAO,MAAM,EAAE,QAAQ,MAAM;AAAA,EAC/B,CAAC;AAED,wBAAG,iCAAiC,YAAY;AAC9C,UAAM,SAAsB;AAAA,MAC1B,MAAM;AAAA,MACN,YAAY;AAAA,QACV,KAAK,EAAE,MAAM,cAAc;AAAA,QAC3B,KAAK,EAAE,MAAM,oBAAoB;AAAA,MACnC;AAAA,MACA,OAAO;AAAA,QACL,KAAK,EAAE,MAAM,SAAS;AAAA,MACxB;AAAA,MACA,aAAa;AAAA,QACX,KAAK,EAAE,MAAM,SAAS;AAAA,MACxB;AAAA,IACF;AACA,UAAM,SAAS,UAAM,uCAAkB,MAAM;AAC7C,8BAAO,MAAM,EAAE,QAAQ;AAAA,MACrB,MAAM;AAAA,MACN,YAAY;AAAA,QACV,KAAK,EAAE,MAAM,SAAS;AAAA,QACtB,KAAK,EAAE,MAAM,SAAS;AAAA,MACxB;AAAA,MACA,OAAO;AAAA,QACL,KAAK,EAAE,MAAM,SAAS;AAAA,MACxB;AAAA,MACA,aAAa;AAAA,QACX,KAAK,EAAE,MAAM,SAAS;AAAA,MACxB;AAAA,IACF,CAAC;AAAA,EACH,CAAC;AAED,wBAAG,gCAAgC,YAAY;AAC7C,UAAM,SAAsB;AAAA,MAC1B,MAAM;AAAA,MACN,YAAY;AAAA,QACV,KAAK,EAAE,MAAM,QAAQ;AAAA,MACvB;AAAA,IACF;AACA,UAAM,SAAS,UAAM,uCAAkB,MAAM;AAC7C,8BAAO,MAAM,EAAE,QAAQ,MAAM;AAAA,EAC/B,CAAC;AACH,CAAC;",
+  "names": []
+}

package/dist/bp-cli/dist/utils/semver-utils.d.ts

@@ -0,0 +1,8 @@
+import semver from 'semver';
+export declare namespace releases {
+    const eq: (a: semver.ReleaseType, b: semver.ReleaseType) => boolean;
+    const gt: (a: semver.ReleaseType, b: semver.ReleaseType) => boolean;
+    const gte: (a: semver.ReleaseType, b: semver.ReleaseType) => boolean;
+    const lt: (a: semver.ReleaseType, b: semver.ReleaseType) => boolean;
+    const lte: (a: semver.ReleaseType, b: semver.ReleaseType) => boolean;
+}

package/dist/bp-cli/dist/utils/semver-utils.js

@@ -0,0 +1,45 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var semver_utils_exports = {};
+__export(semver_utils_exports, {
+  releases: () => releases
+});
+module.exports = __toCommonJS(semver_utils_exports);
+const semverReleases = {
+  prerelease: 0,
+  prepatch: 1,
+  patch: 2,
+  preminor: 3,
+  minor: 4,
+  premajor: 5,
+  major: 6
+};
+var releases;
+((releases2) => {
+  releases2.eq = (a, b) => semverReleases[a] === semverReleases[b];
+  releases2.gt = (a, b) => semverReleases[a] > semverReleases[b];
+  releases2.gte = (a, b) => semverReleases[a] >= semverReleases[b];
+  releases2.lt = (a, b) => semverReleases[a] < semverReleases[b];
+  releases2.lte = (a, b) => semverReleases[a] <= semverReleases[b];
+})(releases || (releases = {}));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  releases
+});
+//# sourceMappingURL=semver-utils.js.map

package/dist/bp-cli/dist/utils/semver-utils.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/semver-utils.ts"],
+  "sourcesContent": ["import semver from 'semver'\n\nconst semverReleases: Record<semver.ReleaseType, number> = {\n  prerelease: 0,\n  prepatch: 1,\n  patch: 2,\n  preminor: 3,\n  minor: 4,\n  premajor: 5,\n  major: 6,\n}\n\nexport namespace releases {\n  export const eq = (a: semver.ReleaseType, b: semver.ReleaseType) => semverReleases[a] === semverReleases[b]\n  export const gt = (a: semver.ReleaseType, b: semver.ReleaseType) => semverReleases[a] > semverReleases[b]\n  export const gte = (a: semver.ReleaseType, b: semver.ReleaseType) => semverReleases[a] >= semverReleases[b]\n  export const lt = (a: semver.ReleaseType, b: semver.ReleaseType) => semverReleases[a] < semverReleases[b]\n  export const lte = (a: semver.ReleaseType, b: semver.ReleaseType) => semverReleases[a] <= semverReleases[b]\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAEA,MAAM,iBAAqD;AAAA,EACzD,YAAY;AAAA,EACZ,UAAU;AAAA,EACV,OAAO;AAAA,EACP,UAAU;AAAA,EACV,OAAO;AAAA,EACP,UAAU;AAAA,EACV,OAAO;AACT;AAEO,IAAU;AAAA,CAAV,CAAUA,cAAV;AACE,EAAMA,UAAA,KAAK,CAAC,GAAuB,MAA0B,eAAe,CAAC,MAAM,eAAe,CAAC;AACnG,EAAMA,UAAA,KAAK,CAAC,GAAuB,MAA0B,eAAe,CAAC,IAAI,eAAe,CAAC;AACjG,EAAMA,UAAA,MAAM,CAAC,GAAuB,MAA0B,eAAe,CAAC,KAAK,eAAe,CAAC;AACnG,EAAMA,UAAA,KAAK,CAAC,GAAuB,MAA0B,eAAe,CAAC,IAAI,eAAe,CAAC;AACjG,EAAMA,UAAA,MAAM,CAAC,GAAuB,MAA0B,eAAe,CAAC,KAAK,eAAe,CAAC;AAAA,GAL3F;",
+  "names": ["releases"]
+}

package/dist/bp-cli/dist/utils/string-utils.d.ts

@@ -0,0 +1,2 @@
+export declare const splitOnce: (text: string, separator: string) => [string, string | undefined];
+export declare function chunkString(input: string, chunkSize: number): Generator<string, void, void>;

package/dist/bp-cli/dist/utils/string-utils.js

@@ -0,0 +1,42 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var string_utils_exports = {};
+__export(string_utils_exports, {
+  chunkString: () => chunkString,
+  splitOnce: () => splitOnce
+});
+module.exports = __toCommonJS(string_utils_exports);
+const splitOnce = (text, separator) => {
+  const index = text.indexOf(separator);
+  if (index === -1) {
+    return [text, void 0];
+  }
+  return [text.slice(0, index), text.slice(index + 1)];
+};
+function* chunkString(input, chunkSize) {
+  for (let i = 0; i < input.length; i += chunkSize) {
+    yield input.slice(i, i + chunkSize);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  chunkString,
+  splitOnce
+});
+//# sourceMappingURL=string-utils.js.map

package/dist/bp-cli/dist/utils/string-utils.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/string-utils.ts"],
+  "sourcesContent": ["export const splitOnce = (text: string, separator: string): [string, string | undefined] => {\n  const index = text.indexOf(separator)\n  if (index === -1) {\n    return [text, undefined]\n  }\n  return [text.slice(0, index), text.slice(index + 1)]\n}\n\nexport function* chunkString(input: string, chunkSize: number): Generator<string, void, void> {\n  for (let i = 0; i < input.length; i += chunkSize) {\n    yield input.slice(i, i + chunkSize)\n  }\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAO,MAAM,YAAY,CAAC,MAAc,cAAoD;AAC1F,QAAM,QAAQ,KAAK,QAAQ,SAAS;AACpC,MAAI,UAAU,IAAI;AAChB,WAAO,CAAC,MAAM,MAAS;AAAA,EACzB;AACA,SAAO,CAAC,KAAK,MAAM,GAAG,KAAK,GAAG,KAAK,MAAM,QAAQ,CAAC,CAAC;AACrD;AAEO,UAAU,YAAY,OAAe,WAAkD;AAC5F,WAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK,WAAW;AAChD,UAAM,MAAM,MAAM,GAAG,IAAI,SAAS;AAAA,EACpC;AACF;",
+  "names": []
+}

package/dist/bp-cli/dist/utils/template-utils.d.ts

@@ -0,0 +1 @@
+export declare const formatHandleBars: (templateStr: string, data: Record<string, string>) => string;

package/dist/bp-cli/dist/utils/template-utils.js

@@ -0,0 +1,51 @@
+"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);
+var template_utils_exports = {};
+__export(template_utils_exports, {
+  formatHandleBars: () => formatHandleBars
+});
+module.exports = __toCommonJS(template_utils_exports);
+var import_handlebars = __toESM(require("handlebars"));
+var casing = __toESM(require("./case-utils"));
+import_handlebars.default.registerHelper("toUpperCase", (s) => s.toUpperCase());
+import_handlebars.default.registerHelper("toLowerCase", (s) => s.toLowerCase());
+import_handlebars.default.registerHelper("pascalCase", casing.to.pascalCase);
+import_handlebars.default.registerHelper("kebabCase", casing.to.kebabCase);
+import_handlebars.default.registerHelper("snakeCase", casing.to.snakeCase);
+import_handlebars.default.registerHelper("screamingSnakeCase", casing.to.screamingSnakeCase);
+import_handlebars.default.registerHelper("camelCase", casing.to.camelCase);
+const formatHandleBars = (templateStr, data) => {
+  const template = import_handlebars.default.compile(templateStr);
+  return template(data);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  formatHandleBars
+});
+//# sourceMappingURL=template-utils.js.map

package/dist/bp-cli/dist/utils/template-utils.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/template-utils.ts"],
+  "sourcesContent": ["import hb from 'handlebars'\nimport * as casing from './case-utils'\n\nhb.registerHelper('toUpperCase', (s) => s.toUpperCase())\nhb.registerHelper('toLowerCase', (s) => s.toLowerCase())\nhb.registerHelper('pascalCase', casing.to.pascalCase)\nhb.registerHelper('kebabCase', casing.to.kebabCase)\nhb.registerHelper('snakeCase', casing.to.snakeCase)\nhb.registerHelper('screamingSnakeCase', casing.to.screamingSnakeCase)\nhb.registerHelper('camelCase', casing.to.camelCase)\n\nexport const formatHandleBars = (templateStr: string, data: Record<string, string>): string => {\n  const template = hb.compile(templateStr)\n  return template(data)\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,wBAAe;AACf,aAAwB;AAExB,kBAAAA,QAAG,eAAe,eAAe,CAAC,MAAM,EAAE,YAAY,CAAC;AACvD,kBAAAA,QAAG,eAAe,eAAe,CAAC,MAAM,EAAE,YAAY,CAAC;AACvD,kBAAAA,QAAG,eAAe,cAAc,OAAO,GAAG,UAAU;AACpD,kBAAAA,QAAG,eAAe,aAAa,OAAO,GAAG,SAAS;AAClD,kBAAAA,QAAG,eAAe,aAAa,OAAO,GAAG,SAAS;AAClD,kBAAAA,QAAG,eAAe,sBAAsB,OAAO,GAAG,kBAAkB;AACpE,kBAAAA,QAAG,eAAe,aAAa,OAAO,GAAG,SAAS;AAE3C,MAAM,mBAAmB,CAAC,aAAqB,SAAyC;AAC7F,QAAM,WAAW,kBAAAA,QAAG,QAAQ,WAAW;AACvC,SAAO,SAAS,IAAI;AACtB;",
+  "names": ["hb"]
+}

package/dist/bp-cli/dist/utils/tunnel-utils.d.ts

@@ -0,0 +1,49 @@
+import { TunnelTail, ClientCloseEvent, ClientErrorEvent } from '@bpinternal/tunnel';
+import { Logger } from '../logger';
+import { EventEmitter } from './event-emitter';
+export type ReconnectionTriggerEvent = {
+    type: 'init';
+    ev: null;
+} | {
+    type: 'error';
+    ev: ClientErrorEvent;
+} | {
+    type: 'close';
+    ev: ClientCloseEvent;
+};
+export type ReconnectedEvent = {
+    tunnel: TunnelTail;
+    ev: ReconnectionTriggerEvent;
+};
+export declare class ReconnectionFailedError extends Error {
+    readonly event: ReconnectionTriggerEvent;
+    constructor(event: ReconnectionTriggerEvent);
+    private static _reason;
+}
+export declare class TunnelSupervisor {
+    private _tunnelUrl;
+    private _tunnelId;
+    private _logger;
+    private _tunnel?;
+    private _closed;
+    private _started;
+    readonly events: EventEmitter<{
+        connectionFailed: ReconnectionTriggerEvent;
+        manuallyClosed: null;
+        connected: {
+            tunnel: TunnelTail;
+            ev: ReconnectionTriggerEvent;
+        };
+    }>;
+    constructor(_tunnelUrl: string, _tunnelId: string, _logger: Logger);
+    start(): Promise<void>;
+    get closed(): boolean;
+    /**
+     * @returns Promise that rejects when a reconnection attempt fails and resolves when the tunnel is closed manually
+     */
+    wait(): Promise<void>;
+    close(): void;
+    private _reconnectSync;
+    private _reconnect;
+    private _registerListeners;
+}

package/dist/bp-cli/dist/utils/tunnel-utils.js

@@ -0,0 +1,132 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var tunnel_utils_exports = {};
+__export(tunnel_utils_exports, {
+  ReconnectionFailedError: () => ReconnectionFailedError,
+  TunnelSupervisor: () => TunnelSupervisor
+});
+module.exports = __toCommonJS(tunnel_utils_exports);
+var import_tunnel = require("@bpinternal/tunnel");
+var import_event_emitter = require("./event-emitter");
+class ReconnectionFailedError extends Error {
+  constructor(event) {
+    const reason = ReconnectionFailedError._reason(event);
+    super(`Reconnection failed: ${reason}`);
+    this.event = event;
+  }
+  static _reason(event) {
+    if (event.type === "error") {
+      return "error";
+    }
+    if (event.type === "close") {
+      return `${event.ev.code} ${event.ev.reason}`;
+    }
+    return "init";
+  }
+}
+class TunnelSupervisor {
+  constructor(_tunnelUrl, _tunnelId, _logger) {
+    this._tunnelUrl = _tunnelUrl;
+    this._tunnelId = _tunnelId;
+    this._logger = _logger;
+  }
+  _tunnel;
+  _closed = false;
+  _started = false;
+  events = new import_event_emitter.EventEmitter();
+  async start() {
+    if (this._closed) {
+      throw new Error("Cannot start: Tunnel is closed");
+    }
+    if (this._started) {
+      throw new Error("Cannot start: Tunnel is already started");
+    }
+    this._started = true;
+    const tunnel = await this._reconnect({ type: "init", ev: null });
+    this._tunnel = tunnel;
+  }
+  get closed() {
+    return this._closed;
+  }
+  /**
+   * @returns Promise that rejects when a reconnection attempt fails and resolves when the tunnel is closed manually
+   */
+  async wait() {
+    if (this._closed) {
+      throw new Error("Cannot wait: Tunnel is closed");
+    }
+    return new Promise((resolve, reject) => {
+      this.events.on("connectionFailed", (ev) => {
+        reject(new ReconnectionFailedError(ev));
+      });
+      this.events.on("manuallyClosed", () => {
+        resolve();
+      });
+    });
+  }
+  close() {
+    if (this._closed) {
+      return;
+    }
+    this._closed = true;
+    this._tunnel?.close();
+    this.events.emit("manuallyClosed", null);
+  }
+  _reconnectSync(ev) {
+    void this._reconnect(ev).then((t) => {
+      this._tunnel = t;
+    }).catch(() => this.events.emit("connectionFailed", ev));
+  }
+  async _reconnect(ev) {
+    const newTunnel = async () => {
+      const tunnel2 = await import_tunnel.TunnelTail.new(this._tunnelUrl, this._tunnelId);
+      this._registerListeners(tunnel2);
+      this.events.emit("connected", { tunnel: tunnel2, ev });
+      return tunnel2;
+    };
+    if (ev.type === "init") {
+      return newTunnel();
+    }
+    const line = this._logger.line();
+    line.started("Reconnecting tunnel...");
+    const tunnel = await newTunnel();
+    line.success("Reconnected");
+    line.commit();
+    return tunnel;
+  }
+  _registerListeners(tunnel) {
+    tunnel.events.on("error", ({ target, type }) => {
+      this._logger.error(`Tunnel error: ${type}`);
+      this._reconnectSync({ type: "error", ev: { target, type } });
+    });
+    tunnel.events.on("close", ({ code, reason, target, type, wasClean }) => {
+      this._logger.error(`Tunnel closed: ${code} ${reason}`);
+      if (code === import_tunnel.errors.CLOSE_CODES.TUNNEL_ID_CONFLICT) {
+        throw new Error("Cannot start: Tunnel Id is already used, choose a different tunnel id.");
+      }
+      this._reconnectSync({ type: "close", ev: { code, reason, target, type, wasClean } });
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ReconnectionFailedError,
+  TunnelSupervisor
+});
+//# sourceMappingURL=tunnel-utils.js.map

package/dist/bp-cli/dist/utils/tunnel-utils.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/tunnel-utils.ts"],
+  "sourcesContent": ["import { TunnelTail, ClientCloseEvent, ClientErrorEvent, errors } from '@bpinternal/tunnel'\nimport { Logger } from '../logger'\nimport { EventEmitter } from './event-emitter'\n\nexport type ReconnectionTriggerEvent =\n  | {\n      type: 'init'\n      ev: null\n    }\n  | {\n      type: 'error'\n      ev: ClientErrorEvent\n    }\n  | {\n      type: 'close'\n      ev: ClientCloseEvent\n    }\n\nexport type ReconnectedEvent = {\n  tunnel: TunnelTail\n  ev: ReconnectionTriggerEvent\n}\n\nexport class ReconnectionFailedError extends Error {\n  public constructor(public readonly event: ReconnectionTriggerEvent) {\n    const reason = ReconnectionFailedError._reason(event)\n    super(`Reconnection failed: ${reason}`)\n  }\n\n  private static _reason(event: ReconnectionTriggerEvent): string {\n    if (event.type === 'error') {\n      return 'error'\n    }\n\n    if (event.type === 'close') {\n      return `${event.ev.code} ${event.ev.reason}`\n    }\n\n    return 'init'\n  }\n}\n\nexport class TunnelSupervisor {\n  private _tunnel?: TunnelTail\n  private _closed = false\n  private _started = false\n\n  public readonly events = new EventEmitter<{\n    connectionFailed: ReconnectionTriggerEvent\n    manuallyClosed: null\n    connected: {\n      tunnel: TunnelTail\n      ev: ReconnectionTriggerEvent\n    }\n  }>()\n\n  public constructor(\n    private _tunnelUrl: string,\n    private _tunnelId: string,\n    private _logger: Logger\n  ) {}\n\n  public async start(): Promise<void> {\n    if (this._closed) {\n      throw new Error('Cannot start: Tunnel is closed')\n    }\n    if (this._started) {\n      throw new Error('Cannot start: Tunnel is already started')\n    }\n\n    this._started = true\n    const tunnel = await this._reconnect({ type: 'init', ev: null })\n    this._tunnel = tunnel\n  }\n\n  public get closed(): boolean {\n    return this._closed\n  }\n\n  /**\n   * @returns Promise that rejects when a reconnection attempt fails and resolves when the tunnel is closed manually\n   */\n  public async wait(): Promise<void> {\n    if (this._closed) {\n      throw new Error('Cannot wait: Tunnel is closed')\n    }\n\n    return new Promise((resolve, reject) => {\n      this.events.on('connectionFailed', (ev) => {\n        reject(new ReconnectionFailedError(ev))\n      })\n\n      this.events.on('manuallyClosed', () => {\n        resolve()\n      })\n    })\n  }\n\n  public close(): void {\n    if (this._closed) {\n      return\n    }\n\n    this._closed = true\n    this._tunnel?.close()\n    this.events.emit('manuallyClosed', null)\n  }\n\n  private _reconnectSync(ev: ReconnectionTriggerEvent): void {\n    void this._reconnect(ev)\n      .then((t) => {\n        this._tunnel = t\n      })\n      .catch(() => this.events.emit('connectionFailed', ev))\n  }\n\n  private async _reconnect(ev: ReconnectionTriggerEvent): Promise<TunnelTail> {\n    const newTunnel = async () => {\n      const tunnel = await TunnelTail.new(this._tunnelUrl, this._tunnelId)\n      this._registerListeners(tunnel)\n      this.events.emit('connected', { tunnel, ev })\n      return tunnel\n    }\n\n    if (ev.type === 'init') {\n      // skip logging on the first connection attempt\n      return newTunnel()\n    }\n\n    const line = this._logger.line()\n    line.started('Reconnecting tunnel...')\n    const tunnel = await newTunnel()\n    line.success('Reconnected')\n    line.commit()\n    return tunnel\n  }\n\n  private _registerListeners(tunnel: TunnelTail) {\n    tunnel.events.on('error', ({ target, type }) => {\n      this._logger.error(`Tunnel error: ${type}`)\n      this._reconnectSync({ type: 'error', ev: { target, type } })\n    })\n    tunnel.events.on('close', ({ code, reason, target, type, wasClean }) => {\n      this._logger.error(`Tunnel closed: ${code} ${reason}`)\n\n      if (code === errors.CLOSE_CODES.TUNNEL_ID_CONFLICT) {\n        throw new Error('Cannot start: Tunnel Id is already used, choose a different tunnel id.')\n      }\n\n      this._reconnectSync({ type: 'close', ev: { code, reason, target, type, wasClean } })\n    })\n  }\n}\n"],
+  "mappings": "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",
+  "names": ["tunnel"]
+}

package/dist/bp-cli/dist/utils/type-utils.d.ts

@@ -0,0 +1,19 @@
+export type Merge<A extends object, B extends object> = Omit<A, keyof B> & B;
+export type SafeOmit<T, K extends keyof T> = Omit<T, K>;
+export type Writable<T> = {
+    -readonly [K in keyof T]: T[K];
+};
+export type AssertNever<_T extends never> = true;
+export type AssertExtends<_A extends B, B> = true;
+export type AssertKeyOf<_K extends keyof T, T> = true;
+export type AssertTrue<_T extends true> = true;
+export type AssertAll<_T extends true[]> = true;
+export type IsExtend<X, Y> = X extends Y ? true : false;
+export type IsEquivalent<X, Y> = IsExtend<X, Y> extends true ? IsExtend<Y, X> : false;
+export type IsIdentical<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? true : false;
+export type IsEqual<X, Y> = IsIdentical<Normalize<X>, Normalize<Y>>;
+type NormalizeObject<T extends object> = T extends infer O ? {
+    [K in keyof O]: Normalize<O[K]>;
+} : never;
+export type Normalize<T> = T extends (...args: infer A) => infer R ? (...args: Normalize<A>) => Normalize<R> : T extends Array<infer E> ? Array<Normalize<E>> : T extends ReadonlyArray<infer E> ? ReadonlyArray<Normalize<E>> : T extends Promise<infer R> ? Promise<Normalize<R>> : T extends Buffer ? Buffer : T extends object ? NormalizeObject<T> : T;
+export {};