@wirecat/mail-cli 0.0.0-stage → 0.1.0

package/dist/bundle/node-TLZSIHIJ.js

@@ -0,0 +1,21 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  child_process,
+  crypto,
+  fs,
+  os,
+  path,
+  stream,
+  util
+} from "./chunk-DFDN6AUB.js";
+import "./chunk-ZVVMGPBJ.js";
+export {
+  child_process,
+  crypto,
+  fs,
+  os,
+  path,
+  stream,
+  util
+};

package/dist/bundle/node-sqlite-NBXQXBIU.js

@@ -0,0 +1,63 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  loadVectorExtension,
+  vectorExtension
+} from "./chunk-ZANYM66S.js";
+import "./chunk-J3QXTBD2.js";
+import "./chunk-LQ37ALDJ.js";
+import "./chunk-Y5E2WNWB.js";
+import "./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/drivers/node-sqlite.js
+import { DatabaseSync } from "node:sqlite";
+var openWithNodeSqlite = /* @__PURE__ */ __name(async (path) => cacheOverNodeSqlite(await nodeClient(path)), "openWithNodeSqlite");
+var nodeClient = /* @__PURE__ */ __name(async (path, { readOnly = false } = {}) => {
+  const extension = await vectorExtension();
+  const client = new DatabaseSync(path, { readOnly, allowExtension: true });
+  try {
+    loadVectorExtension(client, extension);
+    return client;
+  } catch (error) {
+    client.close();
+    throw error;
+  }
+}, "nodeClient");
+var STATEMENT_CACHE_SIZE = 1e3;
+var cacheOverNodeSqlite = /* @__PURE__ */ __name((database, cacheSize = STATEMENT_CACHE_SIZE) => {
+  const statements = /* @__PURE__ */ new Map();
+  const prepare = /* @__PURE__ */ __name((sql) => {
+    const statement = database.prepare(sql);
+    return {
+      run: /* @__PURE__ */ __name((...parameters) => ({ changes: Number(statement.run(...parameters).changes) }), "run"),
+      get: /* @__PURE__ */ __name((...parameters) => statement.get(...parameters), "get"),
+      all: /* @__PURE__ */ __name((...parameters) => statement.all(...parameters), "all")
+    };
+  }, "prepare");
+  return {
+    exec: /* @__PURE__ */ __name((sql) => database.exec(sql), "exec"),
+    prepare: /* @__PURE__ */ __name((sql) => {
+      const cached = statements.get(sql);
+      if (cached)
+        statements.delete(sql);
+      const statement = cached ?? prepare(sql);
+      statements.set(sql, statement);
+      if (statements.size > cacheSize)
+        statements.delete(statements.keys().next().value);
+      return statement;
+    }, "prepare"),
+    close: /* @__PURE__ */ __name(() => {
+      statements.clear();
+      database.close();
+    }, "close")
+  };
+}, "cacheOverNodeSqlite");
+export {
+  STATEMENT_CACHE_SIZE,
+  cacheOverNodeSqlite,
+  nodeClient,
+  openWithNodeSqlite
+};

package/dist/bundle/oauth-56EFO5AQ.js

@@ -0,0 +1,19 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  ownerLogin,
+  revokeAll
+} from "./chunk-BTQX2ZSZ.js";
+import "./chunk-5D4AEUVA.js";
+import "./chunk-GN62YOT5.js";
+import "./chunk-TE5U5OAM.js";
+import "./chunk-KM7Q67Z3.js";
+import "./chunk-J3QXTBD2.js";
+import "./chunk-LQ37ALDJ.js";
+import "./chunk-Y5E2WNWB.js";
+import "./chunk-5BVIWP3S.js";
+import "./chunk-ZVVMGPBJ.js";
+export {
+  ownerLogin,
+  revokeAll
+};

package/dist/bundle/open-2V7QZQJP.js

@@ -0,0 +1,21 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  CAPABILITY_STATEMENTS,
+  assertStoreCapable,
+  openCache,
+  openFile,
+  storeCapable
+} from "./chunk-F6D6PJ34.js";
+import "./chunk-J3QXTBD2.js";
+import "./chunk-LQ37ALDJ.js";
+import "./chunk-Y5E2WNWB.js";
+import "./chunk-5BVIWP3S.js";
+import "./chunk-ZVVMGPBJ.js";
+export {
+  CAPABILITY_STATEMENTS,
+  assertStoreCapable,
+  openCache,
+  openFile,
+  storeCapable
+};

package/dist/bundle/openai-V3SVACVL.js

@@ -0,0 +1,251 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  SAMPLE_RATE,
+  toModelRate
+} from "./chunk-QQB7WT7R.js";
+import "./chunk-75CWWETH.js";
+import {
+  OPENAI_URL
+} from "./chunk-4E7BN3TC.js";
+import "./chunk-Z34ICZA3.js";
+import {
+  OPENAI_TRANSCRIBE_MODEL,
+  VAD,
+  filesPresent,
+  modelsDirectory,
+  vadPath
+} from "./chunk-5NYMNSSO.js";
+import "./chunk-FZ5FXIG6.js";
+import {
+  DEFAULT_RETRY,
+  backoffMs
+} from "./chunk-J3QXTBD2.js";
+import "./chunk-LQ37ALDJ.js";
+import "./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/openai.js
+import { setTimeout as wait } from "node:timers/promises";
+
+// 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/http/index.js
+var parseRetryAfter = /* @__PURE__ */ __name((header, now) => {
+  if (!header)
+    return void 0;
+  const trimmed = header.trim();
+  if (/^\d+$/.test(trimmed))
+    return Number(trimmed) * 1e3;
+  const at = Date.parse(trimmed);
+  if (Number.isNaN(at))
+    return void 0;
+  const delta = at - now().getTime();
+  return delta > 0 ? delta : void 0;
+}, "parseRetryAfter");
+var parseRateLimitReset = /* @__PURE__ */ __name((header, now) => {
+  if (!header)
+    return void 0;
+  const seconds = Number(header.trim());
+  if (!Number.isFinite(seconds))
+    return void 0;
+  const delta = seconds * 1e3 - now().getTime();
+  return delta > 0 ? delta : void 0;
+}, "parseRateLimitReset");
+var providerWaitMs = /* @__PURE__ */ __name((headers, now) => parseRetryAfter(headers.get("retry-after"), now) ?? parseRateLimitReset(headers.get("x-ratelimit-reset"), now), "providerWaitMs");
+
+// 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/wav.js
+var encodeWav = /* @__PURE__ */ __name((samples, sampleRate = 16e3) => {
+  const bytes = Buffer.alloc(44 + samples.length * 2);
+  bytes.write("RIFF", 0, "ascii");
+  bytes.writeUInt32LE(bytes.length - 8, 4);
+  bytes.write("WAVEfmt ", 8, "ascii");
+  bytes.writeUInt32LE(16, 16);
+  bytes.writeUInt16LE(1, 20);
+  bytes.writeUInt16LE(1, 22);
+  bytes.writeUInt32LE(sampleRate, 24);
+  bytes.writeUInt32LE(sampleRate * 2, 28);
+  bytes.writeUInt16LE(2, 32);
+  bytes.writeUInt16LE(16, 34);
+  bytes.write("data", 36, "ascii");
+  bytes.writeUInt32LE(samples.length * 2, 40);
+  samples.forEach((sample, index) => {
+    bytes.writeInt16LE(Math.round(Math.max(-1, Math.min(1, sample || 0)) * 32767), 44 + index * 2);
+  });
+  return new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.length);
+}, "encodeWav");
+
+// 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/openai.js
+var LONGEST_REQUEST_SECONDS = 600;
+var JOINED_SECONDS = 0.2;
+var PAD_SECONDS = 0.2;
+var LEAD = SAMPLE_RATE / 2;
+var EXHAUSTED = /* @__PURE__ */ new Set([
+  "insufficient_quota",
+  "credit_balance_exhausted",
+  "organization_spend_limit_exceeded",
+  "project_spend_limit_exceeded",
+  "organization_usage_limit_exceeded"
+]);
+var RETRY = { ...DEFAULT_RETRY, retries: 4 };
+var interrupted = /* @__PURE__ */ __name((signal) => {
+  if (!signal?.aborted)
+    return;
+  if (signal.reason instanceof CliError)
+    throw signal.reason;
+  const timeout = signal.reason instanceof Error && signal.reason.name === "TimeoutError";
+  throw new CliError(timeout ? "timeout" : "cancelled", "the transcription was interrupted");
+}, "interrupted");
+var sleeping = /* @__PURE__ */ __name((ms, signal) => wait(ms, void 0, signal ? { signal } : {}).then(() => void 0, (error) => {
+  interrupted(signal);
+  throw error;
+}), "sleeping");
+var formOf = /* @__PURE__ */ __name((wav, options) => {
+  const form = new FormData();
+  form.append("file", new Blob([wav], { type: "audio/wav" }), "audio.wav");
+  form.append("model", options.model ?? OPENAI_TRANSCRIBE_MODEL);
+  for (const language of options.languages ?? [])
+    form.append("languages[]", language);
+  for (const keyword of options.keywords ?? [])
+    form.append("keywords[]", keyword);
+  if (options.prompt)
+    form.append("prompt", options.prompt);
+  return form;
+}, "formOf");
+var safe = /* @__PURE__ */ __name((value) => typeof value === "string" && /^[\w.-]{1,64}$/.test(value) ? value : void 0, "safe");
+var failureOf = /* @__PURE__ */ __name(async (response) => {
+  try {
+    const body = await response.json();
+    const code = safe(body.error?.code);
+    const type = safe(body.error?.type);
+    return { ...code ? { code } : {}, ...type ? { type } : {} };
+  } catch {
+    return {};
+  }
+}, "failureOf");
+var send = /* @__PURE__ */ __name(async (wav, options) => {
+  const post = options.fetch ?? fetch;
+  const retry = options.retry ?? RETRY;
+  const sleep = options.sleep ?? sleeping;
+  const random = options.random ?? Math.random;
+  const url = `${(options.baseUrl ?? OPENAI_URL).replace(/\/+$/, "")}/audio/transcriptions`;
+  for (let attempt = 1; ; attempt++) {
+    interrupted(options.signal);
+    let response;
+    try {
+      response = await post(url, {
+        method: "POST",
+        headers: { authorization: `Bearer ${options.apiKey}` },
+        body: formOf(wav, options),
+        ...options.signal ? { signal: options.signal } : {}
+      });
+    } catch {
+      interrupted(options.signal);
+      if (attempt > retry.retries)
+        throw new CliError("network_error", "OpenAI could not be reached", { reason: "network.failed" });
+      await sleep(backoffMs(attempt, retry, random), options.signal);
+      continue;
+    }
+    if (response.ok) {
+      const body = await response.json().catch(() => interrupted(options.signal));
+      if (typeof body?.text !== "string")
+        throw new CliError("invalid_response", "OpenAI answered without a transcript", {
+          reason: "provider.invalid-response"
+        });
+      return body.text.trim();
+    }
+    const { code, type } = await failureOf(response);
+    const status = response.status;
+    const said = `HTTP ${status}${code ? `, ${code}` : type ? `, ${type}` : ""}`;
+    if (status === 401)
+      throw new CliError("authentication_error", `OpenAI refused the key (${said}) \u2014 set it again with \`models keys set openai\``, { reason: "auth.failed" });
+    if (status === 403)
+      throw new CliError("permission_error", `OpenAI refused the request (${said}) \u2014 it answers this when the country or region is not supported, or the key's project may not use the model`, { reason: "access.denied" });
+    if (status === 413)
+      throw new CliError("validation_error", `OpenAI refused the audio as too large (${said})`, {
+        reason: "transcription.too-large"
+      });
+    if (EXHAUSTED.has(code ?? "") || EXHAUSTED.has(type ?? ""))
+      throw new CliError("permission_error", `OpenAI refused: the account's credit, spend limit or usage limit is used up (${said}) \u2014 see the billing page`, { reason: "transcription.quota-exhausted" });
+    const again = status === 408 || status === 429 || status >= 500;
+    const asked = providerWaitMs(response.headers, () => /* @__PURE__ */ new Date());
+    if (again && attempt <= retry.retries && (asked === void 0 || asked <= retry.maxRetryAfterMs)) {
+      await sleep(asked ?? backoffMs(attempt, retry, random), options.signal);
+      continue;
+    }
+    if (status === 429)
+      throw new CliError("rate_limited", `OpenAI answered ${said}`, {
+        reason: "provider.rate-limited",
+        ...asked === void 0 ? {} : { retry_after_ms: asked }
+      });
+    if (status >= 500)
+      throw new CliError([502, 503, 504].includes(status) ? "provider_unavailable" : "provider_error", `OpenAI answered ${said}`, { reason: [502, 503, 504].includes(status) ? "provider.unavailable" : "provider.refused" });
+    throw new CliError("provider_error", `OpenAI answered ${said}`, { reason: "provider.refused" });
+  }
+}, "send");
+var piecesOf = /* @__PURE__ */ __name((spans, limit) => {
+  const pieces = [];
+  for (const span of spans) {
+    const last = pieces.at(-1);
+    const joined = last !== void 0 && span.start - last.end < JOINED_SECONDS;
+    const fits = last !== void 0 && limit !== void 0 && span.end - last.start <= limit;
+    if (last && (fits || joined && span.end - last.start <= LONGEST_REQUEST_SECONDS))
+      last.end = span.end;
+    else
+      pieces.push({ start: span.start, end: span.end });
+  }
+  return pieces;
+}, "piecesOf");
+var openCutter = /* @__PURE__ */ __name(async (vadModel) => {
+  const { openSpeechCutter } = await import("./recognize-PAR66KVM.js");
+  return openSpeechCutter(vadModel);
+}, "openCutter");
+var checkKeywords = /* @__PURE__ */ __name((keywords = []) => {
+  const bad = keywords.find((keyword) => typeof keyword !== "string" || !keyword.trim() || /[<>\r\n]/.test(keyword));
+  if (bad !== void 0)
+    throw new CliError("validation_error", "a keyword must be a non-empty single line without < or > \u2014 OpenAI refuses the whole request otherwise");
+}, "checkKeywords");
+var transcribeOpenAI = /* @__PURE__ */ __name(async (audio, options) => {
+  if (!options.apiKey)
+    throw new CliError("authentication_error", "no OpenAI key \u2014 `models keys set openai`, or OPENAI_API_KEY", {
+      reason: "transcription.no-key"
+    });
+  checkKeywords(options.keywords);
+  interrupted(options.signal);
+  const pcm = toModelRate(audio.samples, audio.rate);
+  const duration = (pcm.length - LEAD) / SAMPLE_RATE;
+  if (options.bundle && duration <= LONGEST_REQUEST_SECONDS) {
+    const text = await send(encodeWav(pcm.subarray(LEAD)), options);
+    return text ? [{ start: 0, end: duration, text }] : [];
+  }
+  const vadModel = options.vadModel ?? vadPath(modelsDirectory(options.env));
+  if (!options.cutter && !filesPresent([[VAD, vadModel]]))
+    throw new CliError("not_found", "the voice detector that finds the speech is not on this machine \u2014 it comes with any speech model: `models download`", { reason: "model.not-downloaded", model: "silero_vad" });
+  const cutter = await (options.cutter ?? openCutter)(vadModel);
+  let spans;
+  try {
+    spans = cutter.cut(pcm);
+  } finally {
+    cutter.free();
+  }
+  const pieces = piecesOf(spans, options.bundle ? LONGEST_REQUEST_SECONDS : void 0);
+  const heard = [];
+  for (const [index, piece] of pieces.entries()) {
+    const end = Math.min(piece.end, duration);
+    const from = Math.max(piece.start - PAD_SECONDS, pieces[index - 1]?.end ?? 0);
+    const to = Math.min(end + PAD_SECONDS, pieces[index + 1]?.start ?? duration);
+    const samples = pcm.subarray(LEAD + Math.floor(from * SAMPLE_RATE), LEAD + Math.ceil(to * SAMPLE_RATE));
+    const text = await send(encodeWav(samples), options);
+    if (text)
+      heard.push({ start: Math.min(piece.start, end), end, text });
+  }
+  return heard;
+}, "transcribeOpenAI");
+export {
+  LONGEST_REQUEST_SECONDS,
+  piecesOf,
+  transcribeOpenAI
+};

package/dist/bundle/process-XVDX4SPD.js

@@ -0,0 +1,91 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import "./chunk-Y5E2WNWB.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/embeddings/process.js
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline";
+import { fileURLToPath } from "node:url";
+var openProcess = /* @__PURE__ */ __name(async (model, directory, { threads }) => {
+  const child = await modelProcess({ model, directory, threads });
+  return {
+    model,
+    embed: /* @__PURE__ */ __name(async (texts, kind) => ((await child.ask({ texts, kind })).vectors ?? []).map((vector) => Float32Array.from(vector)), "embed"),
+    close: child.close
+  };
+}, "openProcess");
+var openRerankerProcess = /* @__PURE__ */ __name(async (model, directory, { threads }) => {
+  const child = await modelProcess({ model, directory, threads, rerank: true });
+  return {
+    model,
+    score: /* @__PURE__ */ __name(async (question, passages) => (await child.ask({ question, texts: passages })).scores ?? [], "score"),
+    close: child.close
+  };
+}, "openRerankerProcess");
+var modelProcess = /* @__PURE__ */ __name(async (setup) => {
+  const child = spawn(process.execPath, [fileURLToPath(new URL("./child.js", new URL("embeddings/process.js", import.meta.resolve("@wirecat/cli-core")).href)), JSON.stringify(setup)], { stdio: ["pipe", "pipe", "pipe"] });
+  const pending = /* @__PURE__ */ new Map();
+  let said = "";
+  child.stderr.setEncoding("utf8").on("data", (text) => {
+    said = (said + text).slice(-2e3);
+  });
+  let ready = /* @__PURE__ */ __name(() => {
+  }, "ready");
+  let refused = /* @__PURE__ */ __name((_error) => {
+  }, "refused");
+  const started = new Promise((resolve, reject) => {
+    ready = resolve;
+    refused = reject;
+  });
+  let gone;
+  const stopped = /* @__PURE__ */ __name((error) => {
+    gone ??= error;
+    refused(error);
+    for (const job of pending.values())
+      job.reject(error);
+    pending.clear();
+  }, "stopped");
+  const exited = new Promise((resolve) => {
+    child.once("exit", (code) => {
+      const last = said.trim().split("\n").at(-1);
+      stopped(new Error(`the embedding process stopped (exit ${code})${last ? `: ${last}` : ""}`));
+      resolve();
+    });
+  });
+  child.once("error", stopped);
+  createInterface({ input: child.stdout }).on("line", (line) => {
+    const answer = JSON.parse(line);
+    if ("ready" in answer)
+      return ready();
+    const job = pending.get(answer.id);
+    pending.delete(answer.id);
+    if (answer.error !== void 0 || !(answer.vectors ?? answer.scores))
+      job?.reject(new Error(answer.error ?? "no answer"));
+    else
+      job?.resolve(answer);
+  });
+  await started;
+  let next = 0;
+  return {
+    ask: /* @__PURE__ */ __name((request) => new Promise((resolve, reject) => {
+      if (gone)
+        return reject(gone);
+      const id = next++;
+      pending.set(id, { resolve, reject });
+      child.stdin.write(`${JSON.stringify({ id, ...request })}
+`);
+    }), "ask"),
+    close: /* @__PURE__ */ __name(async () => {
+      if (child.exitCode === null && child.signalCode === null)
+        child.stdin.end();
+      await exited;
+    }, "close")
+  };
+}, "modelProcess");
+export {
+  openProcess,
+  openRerankerProcess
+};