@wirecat/mail-cli 0.0.0-stage → 0.1.1

package/dist/bundle/chunk-ZANYM66S.js

@@ -0,0 +1,58 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  importFrom
+} from "./chunk-Y5E2WNWB.js";
+import {
+  CliError
+} from "./chunk-5BVIWP3S.js";
+import {
+  __name
+} from "./chunk-ZVVMGPBJ.js";
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/store/vector-extension.js
+import { readFileSync } from "node:fs";
+var musl = /* @__PURE__ */ __name(() => {
+  if (process.platform !== "linux")
+    return false;
+  try {
+    return readFileSync("/proc/self/maps", "utf8").includes("ld-musl");
+  } catch {
+    return false;
+  }
+}, "musl");
+var found;
+var vectorExtension = /* @__PURE__ */ __name(() => {
+  found ??= locate();
+  return found;
+}, "vectorExtension");
+var locate = /* @__PURE__ */ __name(async () => {
+  const onMusl = musl();
+  const target = `${process.platform}-${process.arch}${onMusl ? "-musl" : ""}`;
+  let path;
+  try {
+    const { extensionFor } = await importFrom(new URL("store/vector-extension.js", import.meta.resolve("@wirecat/cli-core")).href, "@wirecat/cli-core-sqlite");
+    path = extensionFor({ musl: onMusl });
+  } catch {
+    path = void 0;
+  }
+  if (path === void 0) {
+    found = void 0;
+    throw new CliError("configuration_error", `the message store needs the sqlite-vec extension, and @wirecat/cli-core-sqlite has none for ${target} \u2014 reinstall the CLI so its dependencies install with it (an install that skips optional or native packages leaves it out)`, { reason: "store.vector-extension-missing", target });
+  }
+  return path;
+}, "locate");
+var loadVectorExtension = /* @__PURE__ */ __name((database, path) => {
+  try {
+    database.loadExtension(path);
+  } catch (error) {
+    throw new CliError("configuration_error", `the sqlite-vec extension did not load on ${process.platform}-${process.arch} \u2014 reinstall the CLI; on macOS under Bun, @wirecat/cli-core-sqlite's SQLite must be installed, since the system's cannot load extensions`, { reason: "store.vector-extension-failed", cause: error instanceof Error ? error.message : String(error) });
+  } finally {
+    database.enableLoadExtension?.(false);
+  }
+}, "loadVectorExtension");
+
+export {
+  vectorExtension,
+  loadVectorExtension
+};

package/dist/bundle/chunk-ZD3WUGR2.js

@@ -0,0 +1,142 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  executableEnvironment,
+  executableOnPath
+} from "./chunk-P7P5MNAU.js";
+import {
+  require_cross_spawn
+} from "./chunk-D72URWJE.js";
+import {
+  loadConfigFile,
+  saveConfigFile
+} from "./chunk-J3QXTBD2.js";
+import {
+  number,
+  object,
+  optional,
+  string
+} from "./chunk-LQ37ALDJ.js";
+import {
+  __name,
+  __toESM
+} from "./chunk-ZVVMGPBJ.js";
+
+// node_modules/.pnpm/@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_typescript@7.0.2_vitest@5.0.5/node_modules/@wirecat/cli-base/dist/update/index.js
+var import_cross_spawn = __toESM(require_cross_spawn(), 1);
+import { existsSync } from "node:fs";
+var updateCommand = /* @__PURE__ */ __name((installer, packageName) => {
+  const target = `${packageName}@latest`;
+  switch (installer) {
+    // pnpm 11 installs only versions a day old (minimumReleaseAge 1440); a fix must reach users the day it ships.
+    // Only the package's own scope is exempt — every other dependency keeps the wait.
+    case "pnpm":
+      return ["pnpm", "add", "-g", target, `--config.minimumReleaseAgeExclude=${ownScope(packageName)}`];
+    case "npm":
+      return ["npm", "install", "-g", target];
+    case "bun":
+      return ["bun", "add", "-g", target];
+    default:
+      return void 0;
+  }
+}, "updateCommand");
+var ownScope = /* @__PURE__ */ __name((packageName) => packageName.startsWith("@") ? `${packageName.split("/", 1)[0]}/*` : packageName, "ownScope");
+var isNewer = /* @__PURE__ */ __name((candidate, current) => {
+  const parse = /* @__PURE__ */ __name((version) => /^\d+\.\d+\.\d+$/.test(version) ? version.split(".").map(Number) : void 0, "parse");
+  const a = parse(candidate);
+  const b = parse(current);
+  if (!a || !b)
+    return false;
+  for (let i = 0; i < 3; i++) {
+    if (a[i] !== b[i])
+      return a[i] > b[i];
+  }
+  return false;
+}, "isNewer");
+var latestVersion = /* @__PURE__ */ __name(async (packageName, fetch, { timeoutMs = 1e3 } = {}) => {
+  try {
+    const response = await fetch(`https://registry.npmjs.org/${packageName}/latest`, {
+      signal: AbortSignal.timeout(timeoutMs),
+      headers: { accept: "application/json" }
+    });
+    if (!response.ok)
+      return void 0;
+    const { version } = await response.json();
+    return typeof version === "string" ? version : void 0;
+  } catch {
+    return void 0;
+  }
+}, "latestVersion");
+var CHECK_EVERY_MS = 24 * 60 * 60 * 1e3;
+var mayNotify = /* @__PURE__ */ __name(({ format, stderrIsTTY, quiet, enabled, installer, env, offVariables = [] }) => enabled && format === "pretty" && stderrIsTTY && !quiet && updateCommand(installer, "any") !== void 0 && !env.CI && !env.NO_UPDATE_NOTIFIER && offVariables.every((name) => !env[name]), "mayNotify");
+var updateState = object({
+  checkedAt: number(),
+  latest: optional(string()),
+  /** When the skill hint (`cli-base/skill`) was last shown — the other daily notice kept in this file. */
+  skillHintAt: optional(number())
+});
+var readNoticeState = /* @__PURE__ */ __name((path) => {
+  try {
+    return loadConfigFile(path, updateState, () => ({ checkedAt: 0 }));
+  } catch {
+    return { checkedAt: 0 };
+  }
+}, "readNoticeState");
+var readUpdateState = /* @__PURE__ */ __name((path) => {
+  const state = readNoticeState(path);
+  return state.checkedAt > 0 ? state : void 0;
+}, "readUpdateState");
+var writeUpdateState = /* @__PURE__ */ __name((path, state) => {
+  try {
+    saveConfigFile(path, { ...readNoticeState(path), ...state });
+  } catch {
+  }
+}, "writeUpdateState");
+var checkIsDue = /* @__PURE__ */ __name((state, now) => state === void 0 || now - state.checkedAt >= CHECK_EVERY_MS, "checkIsDue");
+var spawnPlan = /* @__PURE__ */ __name(([command, ...args], platform = process.platform, env = process.env, exists = existsSync) => ({ file: executableOnPath(command, env, platform, exists), args, shell: false }), "spawnPlan");
+var runUpdate = /* @__PURE__ */ __name((argv) => {
+  const { file, args, shell } = spawnPlan(argv);
+  const { status, error } = import_cross_spawn.default.sync(file, args, {
+    stdio: ["inherit", 2, 2],
+    shell,
+    env: executableEnvironment(process.env)
+  });
+  if (error)
+    throw new Error(`could not start ${argv[0]}: ${error.message}`);
+  return status ?? 1;
+}, "runUpdate");
+var updateNotice = /* @__PURE__ */ __name(async ({ argv, packageName, command, upgradeCommand = "upgrade", version, statePath, fetch, now = Date.now, ...context }) => {
+  try {
+    const path = commandWords(argv).slice(0, 2);
+    if (path.includes("complete") || path.includes(upgradeCommand))
+      return void 0;
+    if (!mayNotify(context))
+      return void 0;
+    const at = now();
+    let state = readUpdateState(statePath);
+    if (checkIsDue(state, at)) {
+      const found = await latestVersion(packageName, fetch, { timeoutMs: 1e3 });
+      const seen = found ?? state?.latest;
+      state = seen ? { checkedAt: at, latest: seen } : { checkedAt: at };
+      writeUpdateState(statePath, state);
+    }
+    return state?.latest && isNewer(state.latest, version) ? `${command} ${state.latest} is out \u2014 you have ${version}. \`${command} ${upgradeCommand}\` installs it.` : void 0;
+  } catch {
+    return void 0;
+  }
+}, "updateNotice");
+var commandWords = /* @__PURE__ */ __name((argv) => {
+  const end = argv.indexOf("--");
+  return argv.slice(0, end < 0 ? void 0 : end).filter((word) => !word.startsWith("-"));
+}, "commandWords");
+
+export {
+  updateCommand,
+  isNewer,
+  latestVersion,
+  CHECK_EVERY_MS,
+  readNoticeState,
+  writeUpdateState,
+  runUpdate,
+  updateNotice
+};

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-WU434ZUL.js

@@ -0,0 +1,34 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  SCHEMA_DIALECT,
+  commandContract,
+  commandPathOf,
+  findCommand,
+  outputOf
+} from "./chunk-MS53RALV.js";
+import "./chunk-TVREDYX4.js";
+import "./chunk-GQQJOH7A.js";
+import "./chunk-QLEUNU6G.js";
+import "./chunk-7SXGLT6T.js";
+import "./chunk-WLFLBWNH.js";
+import "./chunk-KM7Q67Z3.js";
+import "./chunk-6MAZWSC3.js";
+import "./chunk-3KEVLSNN.js";
+import "./chunk-UH4DDRHA.js";
+import "./chunk-NPGVOZVK.js";
+import "./chunk-KHTO2Q6E.js";
+import "./chunk-5NYMNSSO.js";
+import "./chunk-FZ5FXIG6.js";
+import "./chunk-J3QXTBD2.js";
+import "./chunk-LQ37ALDJ.js";
+import "./chunk-Y5E2WNWB.js";
+import "./chunk-5BVIWP3S.js";
+import "./chunk-ZVVMGPBJ.js";
+export {
+  SCHEMA_DIALECT,
+  commandContract,
+  commandPathOf,
+  findCommand,
+  outputOf
+};

package/dist/bundle/decode-YB3ZDTES.js

@@ -0,0 +1,162 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  SAMPLE_RATE,
+  decodeOgg
+} from "./chunk-QQB7WT7R.js";
+import "./chunk-J3QXTBD2.js";
+import "./chunk-LQ37ALDJ.js";
+import {
+  importFrom
+} from "./chunk-Y5E2WNWB.js";
+import {
+  CliError
+} from "./chunk-5BVIWP3S.js";
+import {
+  __name
+} from "./chunk-ZVVMGPBJ.js";
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/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
+};