@wirecat/bitrix24-cli 0.0.0-stage → 0.2.0

package/dist/bundle/chunk-ZIAQPTUS.js

@@ -0,0 +1,82 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  MAX_SECRET_INPUT,
+  bufferedInput,
+  inputPolicy
+} from "./chunk-EXOOKUEA.js";
+import {
+  CliError
+} from "./chunk-IRV2PCQ2.js";
+import {
+  __name
+} from "./chunk-ZVVMGPBJ.js";
+
+// node_modules/.pnpm/@wirecat+cli-core@0.586.0_@wirecat+cli-base@0.79.0_commander@15.0.0_esbuild@0.28.2_type_bdecddef0ae5a50ae90cab8b9e35c13b/node_modules/@wirecat/cli-core/dist/terminal/prompt.js
+import { createInterface } from "node:readline";
+import { Writable } from "node:stream";
+var readSecret = /* @__PURE__ */ __name(async (prompt, { input = process.stdin, output = process.stderr, echo = false, signal: givenSignal } = {}) => {
+  const policy = inputPolicy(input);
+  const signals = [givenSignal, policy.signal].filter((one) => one !== void 0);
+  const signal = signals.length ? AbortSignal.any(signals) : void 0;
+  const cancelled = /* @__PURE__ */ __name(() => new CliError("cancelled", "cancelled \u2014 nothing was stored"), "cancelled");
+  if (signal?.aborted)
+    throw cancelled();
+  if (input.isTTY && policy.noInput)
+    throw new CliError("validation_error", "interactive input is disabled \u2014 provide the input through a pipe", {
+      reason: "input.required"
+    });
+  if (!input.isTTY) {
+    return (await bufferedInput(input, {
+      maxBytes: Math.min(policy.maxBytes ?? MAX_SECRET_INPUT, MAX_SECRET_INPUT),
+      ...signal ? { signal } : {}
+    })).toString("utf8").trim();
+  }
+  let muted = false;
+  const shim = new Writable({
+    write(chunk, _encoding, done) {
+      if (!muted)
+        output.write(chunk);
+      done();
+    }
+  });
+  const reader = createInterface({ input, output: shim, terminal: true });
+  const abort = /* @__PURE__ */ __name(() => reader.close(), "abort");
+  let bytes = 0;
+  let inputFailure;
+  const data = /* @__PURE__ */ __name((chunk) => {
+    bytes += Buffer.byteLength(chunk);
+    if (bytes > Math.min(policy.maxBytes ?? MAX_SECRET_INPUT, MAX_SECRET_INPUT)) {
+      inputFailure = new CliError("validation_error", "secret input exceeds its byte limit", {
+        reason: "input.too-large",
+        retryable: false
+      });
+      reader.close();
+    }
+  }, "data");
+  const inputError = /* @__PURE__ */ __name((error) => {
+    inputFailure = error;
+    reader.close();
+  }, "inputError");
+  input.on("data", data).on("error", inputError);
+  try {
+    const answer = await new Promise((resolve, reject) => {
+      const cancel = /* @__PURE__ */ __name(() => reject(inputFailure ?? cancelled()), "cancel");
+      reader.once("SIGINT", cancel);
+      reader.once("close", cancel);
+      signal?.addEventListener("abort", abort, { once: true });
+      reader.question(prompt, resolve);
+      muted = !echo;
+    });
+    return answer.trim();
+  } finally {
+    input.off("data", data).off("error", inputError);
+    signal?.removeEventListener("abort", abort);
+    reader.close();
+    output.write("\n");
+  }
+}, "readSecret");
+
+export {
+  readSecret
+};

package/dist/bundle/chunk-ZVVMGPBJ.js

@@ -0,0 +1,50 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+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 __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
+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
+));
+
+export {
+  __name,
+  __require,
+  __commonJS,
+  __export,
+  __toESM
+};

package/dist/bundle/command-contract-OKQOE6G4.js

@@ -0,0 +1,30 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  SCHEMA_DIALECT,
+  commandContract,
+  commandPathOf,
+  findCommand,
+  outputOf
+} from "./chunk-XRFJWHY5.js";
+import "./chunk-U5ACMCAQ.js";
+import "./chunk-FOTREPNS.js";
+import "./chunk-CNNEA2M4.js";
+import "./chunk-XJXONOB5.js";
+import "./chunk-SGRYYE4X.js";
+import "./chunk-XD4FRDSL.js";
+import "./chunk-P364PLIK.js";
+import "./chunk-TE3FR6MI.js";
+import "./chunk-DTXERR44.js";
+import "./chunk-ZGZT5S6B.js";
+import "./chunk-LRGYKOCP.js";
+import "./chunk-IRV2PCQ2.js";
+import "./chunk-Y5E2WNWB.js";
+import "./chunk-ZVVMGPBJ.js";
+export {
+  SCHEMA_DIALECT,
+  commandContract,
+  commandPathOf,
+  findCommand,
+  outputOf
+};

package/dist/bundle/decode-5ZPLTYV6.js

@@ -0,0 +1,160 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  SAMPLE_RATE,
+  decodeOgg
+} from "./chunk-6WY72XVQ.js";
+import {
+  CliError
+} from "./chunk-IRV2PCQ2.js";
+import {
+  importFrom
+} from "./chunk-Y5E2WNWB.js";
+import {
+  __name
+} from "./chunk-ZVVMGPBJ.js";
+
+// node_modules/.pnpm/@wirecat+cli-core@0.586.0_@wirecat+cli-base@0.79.0_commander@15.0.0_esbuild@0.28.2_type_bdecddef0ae5a50ae90cab8b9e35c13b/node_modules/@wirecat/cli-core/dist/speech/decode.js
+import { spawn } from "node:child_process";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+var LONGEST_AUDIO_SECONDS = 3600;
+var FFMPEG_TIMEOUT_MS = 12e4;
+var FFMPEG_FORMATS = "mov,mp4,m4a,3gp,3g2,mj2,aac,mp3,wav,amr,caf,aiff,flac,ogg,matroska,webm,asf";
+var text = /* @__PURE__ */ __name((bytes, from, length) => String.fromCharCode(...bytes.subarray(from, from + length)), "text");
+var contains = /* @__PURE__ */ __name((bytes, needle, within) => Buffer.from(bytes.buffer, bytes.byteOffset, Math.min(bytes.length, within)).includes(needle, 0, "latin1"), "contains");
+var formatOf = /* @__PURE__ */ __name((bytes) => {
+  if (text(bytes, 0, 4) === "OggS") {
+    if (contains(bytes, "OpusHead", 128))
+      return "opus";
+    if (contains(bytes, "
vorbis", 128))
+      return "vorbis";
+    return "other";
+  }
+  if (text(bytes, 0, 4) === "fLaC")
+    return "flac";
+  const frame = bytes[0] === 255 && ((bytes[1] ?? 0) & 224) === 224 && ((bytes[1] ?? 0) >> 1 & 3) !== 0;
+  if (text(bytes, 0, 3) === "ID3" || frame)
+    return "mp3";
+  return "other";
+}, "formatOf");
+var everyChannel = /* @__PURE__ */ __name((decoded) => {
+  if (!decoded.channelData[0] || decoded.samplesDecoded === 0)
+    throw new CliError("validation_error", "no audio in that file");
+  return decoded.channelData.map((samples) => ({ samples, rate: decoded.sampleRate }));
+}, "everyChannel");
+var load = /* @__PURE__ */ __name((name) => importFrom(new URL("speech/decode.js", import.meta.resolve("@wirecat/cli-core")).href, pathToFileURL(createRequire(new URL("speech/decode.js", import.meta.resolve("@wirecat/cli-core")).href).resolve(name)).href), "load");
+var decodeVorbis = /* @__PURE__ */ __name(async (bytes) => {
+  const { OggVorbisDecoder } = await load("@wasm-audio-decoders/ogg-vorbis");
+  const decoder = new OggVorbisDecoder();
+  await decoder.ready;
+  try {
+    return everyChannel(await decoder.decodeFile(bytes));
+  } finally {
+    decoder.free();
+  }
+}, "decodeVorbis");
+var decodeFlac = /* @__PURE__ */ __name(async (bytes) => {
+  const { FLACDecoder } = await load("@wasm-audio-decoders/flac");
+  const decoder = new FLACDecoder();
+  await decoder.ready;
+  try {
+    return everyChannel(await decoder.decodeFile(bytes));
+  } finally {
+    decoder.free();
+  }
+}, "decodeFlac");
+var decodeMp3 = /* @__PURE__ */ __name(async (bytes) => {
+  const { MPEGDecoder } = await load("mpg123-decoder");
+  const decoder = new MPEGDecoder();
+  await decoder.ready;
+  try {
+    return everyChannel(decoder.decode(bytes));
+  } finally {
+    decoder.free();
+  }
+}, "decodeMp3");
+var runFfmpeg = /* @__PURE__ */ __name(async (bytes) => {
+  const directory = await mkdtemp(join(tmpdir(), "wirecat-audio-"));
+  try {
+    const input = join(directory, "audio");
+    await writeFile(input, bytes, { mode: 384 });
+    const largest = LONGEST_AUDIO_SECONDS * SAMPLE_RATE * 4;
+    const output = await new Promise((resolve, reject) => {
+      const child = spawn("ffmpeg", [
+        "-nostdin",
+        "-hide_banner",
+        "-loglevel",
+        "error",
+        "-protocol_whitelist",
+        "file",
+        "-format_whitelist",
+        FFMPEG_FORMATS,
+        "-i",
+        input,
+        "-vn",
+        "-ac",
+        "1",
+        "-ar",
+        String(SAMPLE_RATE),
+        "-f",
+        "f32le",
+        "pipe:1"
+      ], { stdio: ["ignore", "pipe", "pipe"], timeout: FFMPEG_TIMEOUT_MS });
+      const chunks = [];
+      let size = 0;
+      let errors = "";
+      child.stdout.on("data", (chunk) => {
+        size += chunk.length;
+        if (size > largest)
+          child.kill();
+        else
+          chunks.push(chunk);
+      });
+      child.stderr.on("data", (chunk) => {
+        errors = (errors + chunk.toString()).slice(-500);
+      });
+      child.on("error", (error) => reject(error.code === "ENOENT" ? new CliError("validation_error", "only ffmpeg reads this audio format, and ffmpeg is not installed") : error));
+      child.on("close", (code) => {
+        if (size > largest)
+          reject(new CliError("validation_error", `the audio is longer than ${LONGEST_AUDIO_SECONDS / 60} minutes`));
+        else if (code === 0)
+          resolve(Buffer.concat(chunks));
+        else
+          reject(new CliError("validation_error", `ffmpeg could not read the audio: ${errors.trim() || code}`));
+      });
+    });
+    const samples = new Float32Array(Math.floor(output.length / 4));
+    Buffer.from(samples.buffer).set(output.subarray(0, samples.length * 4));
+    return { samples, rate: SAMPLE_RATE };
+  } finally {
+    await rm(directory, { recursive: true, force: true });
+  }
+}, "runFfmpeg");
+var BUNDLED = {
+  opus: decodeOgg,
+  vorbis: decodeVorbis,
+  flac: decodeFlac,
+  mp3: decodeMp3
+};
+var tooLong = /* @__PURE__ */ __name((pcm) => pcm.samples.length / pcm.rate > LONGEST_AUDIO_SECONDS, "tooLong");
+var decodeChannels = /* @__PURE__ */ __name(async (bytes, ffmpeg = runFfmpeg) => {
+  const format = formatOf(bytes);
+  const decoded = format === "other" ? { channels: [await ffmpeg(bytes)], mixed: true } : await BUNDLED[format](bytes).then((channels) => ({ channels, mixed: false }), (error) => ffmpeg(bytes).then((pcm) => ({ channels: [pcm], mixed: true }), () => {
+    throw error;
+  }));
+  if (decoded.channels.some(tooLong))
+    throw new CliError("validation_error", `the audio is longer than ${LONGEST_AUDIO_SECONDS / 60} minutes`);
+  return decoded;
+}, "decodeChannels");
+var decodeAudio = /* @__PURE__ */ __name(async (bytes, ffmpeg = runFfmpeg) => (await decodeChannels(bytes, ffmpeg)).channels[0], "decodeAudio");
+export {
+  LONGEST_AUDIO_SECONDS,
+  decodeAudio,
+  decodeChannels,
+  formatOf,
+  runFfmpeg
+};