@wirecat/mail-cli 0.0.0-stage → 0.1.0

package/dist/bundle/chunk-F6D6PJ34.js

@@ -0,0 +1,100 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+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/driver.js
+var PRAGMAS = `
+  PRAGMA busy_timeout = 5000;
+  PRAGMA journal_mode = WAL;
+  PRAGMA foreign_keys = ON;
+`;
+
+// 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/sqlite-warning.js
+var SQLITE_WARNING = "SQLite is an experimental feature";
+var quieted = /* @__PURE__ */ new WeakSet();
+var quietSqliteWarning = /* @__PURE__ */ __name((host = process) => {
+  if (quieted.has(host))
+    return;
+  quieted.add(host);
+  const emit = host.emitWarning;
+  host.emitWarning = function(warning, ...rest) {
+    if (isSqliteWarning(warning, rest[0]))
+      return;
+    return Reflect.apply(emit, this, [warning, ...rest]);
+  };
+}, "quietSqliteWarning");
+var isSqliteWarning = /* @__PURE__ */ __name((warning, options) => {
+  const type = typeof options === "string" ? options : options?.type;
+  const name = typeof warning === "string" ? type : warning.name;
+  const message = typeof warning === "string" ? warning : warning.message;
+  return name === "ExperimentalWarning" && message.startsWith(SQLITE_WARNING);
+}, "isSqliteWarning");
+
+// 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/open.js
+var openCache = /* @__PURE__ */ __name(async (path) => {
+  const database = await openFile(path);
+  try {
+    database.exec(PRAGMAS);
+  } catch (error) {
+    database.close();
+    throw error;
+  }
+  return database;
+}, "openCache");
+var openFile = /* @__PURE__ */ __name((path) => "Bun" in globalThis ? openUnderBun(path) : openUnderNode(path), "openFile");
+var openUnderBun = /* @__PURE__ */ __name(async (path) => {
+  const { openWithBunSqlite } = await import("./bun-sqlite-Z54LEHVM.js");
+  return await openWithBunSqlite(path);
+}, "openUnderBun");
+var openUnderNode = /* @__PURE__ */ __name(async (path) => {
+  quietSqliteWarning();
+  const { openWithNodeSqlite } = await import("./node-sqlite-NBXQXBIU.js");
+  return openWithNodeSqlite(path);
+}, "openUnderNode");
+var runtime = /* @__PURE__ */ __name(() => {
+  const bun = globalThis.Bun;
+  return bun ? `Bun ${bun.version}` : `Node ${process.versions.node}`;
+}, "runtime");
+var CAPABILITY_STATEMENTS = [
+  `CREATE VIRTUAL TABLE temp.capability_words USING fts5(a, content = '', contentless_delete = 1,
+     tokenize = 'unicode61 remove_diacritics 2')`,
+  "CREATE VIRTUAL TABLE temp.capability_text USING fts5(a, tokenize = 'trigram')",
+  "DROP TABLE temp.capability_words",
+  "DROP TABLE temp.capability_text"
+];
+var assertStoreCapable = /* @__PURE__ */ __name((database, on = runtime()) => {
+  try {
+    for (const statement of CAPABILITY_STATEMENTS)
+      database.exec(statement);
+  } catch (error) {
+    const version = String(database.prepare("SELECT sqlite_version() AS version").get()?.version);
+    const remedy = on.startsWith("Bun") ? "Run it under Node 22.16 or newer instead" : "Update Node to 22.16 or newer, or run it under Bun";
+    throw new CliError("configuration_error", `the message store needs full-text search that this SQLite (${version}, ${on}) does not have. ${remedy}.`, { sqlite: version, runtime: on, cause: error instanceof Error ? error.message : String(error) });
+  }
+}, "assertStoreCapable");
+var capable;
+var storeCapable = /* @__PURE__ */ __name(() => {
+  capable ??= openCache(":memory:").then((database) => {
+    try {
+      assertStoreCapable(database);
+    } finally {
+      database.close();
+    }
+  });
+  return capable;
+}, "storeCapable");
+
+export {
+  PRAGMAS,
+  quietSqliteWarning,
+  openCache,
+  openFile,
+  CAPABILITY_STATEMENTS,
+  assertStoreCapable,
+  storeCapable
+};

package/dist/bundle/chunk-FDCGTODC.js

@@ -0,0 +1,78 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+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/http/listen.js
+import { createServer } from "node:http";
+import { Readable } from "node:stream";
+var MAX_BODY = 4 * 1024 * 1024;
+var TooLarge = class extends Error {
+  static {
+    __name(this, "TooLarge");
+  }
+};
+var readBody = /* @__PURE__ */ __name((incoming, limit) => new Promise((resolve, reject) => {
+  if (Number(incoming.headers["content-length"] ?? 0) > limit)
+    return reject(new TooLarge());
+  const chunks = [];
+  let size = 0;
+  incoming.on("data", (chunk) => {
+    size += chunk.length;
+    if (size > limit) {
+      incoming.destroy();
+      reject(new TooLarge());
+    } else
+      chunks.push(chunk);
+  });
+  incoming.once("end", () => resolve(Buffer.concat(chunks)));
+  incoming.once("error", reject);
+}), "readBody");
+var toRequest = /* @__PURE__ */ __name(async (incoming, origin, maxBody) => {
+  const headers = new Headers();
+  for (const [name, value] of Object.entries(incoming.headers)) {
+    if (Array.isArray(value))
+      for (const one of value)
+        headers.append(name, one);
+    else if (value !== void 0)
+      headers.set(name, value);
+  }
+  const method = incoming.method ?? "GET";
+  const body = method === "GET" || method === "HEAD" ? void 0 : await readBody(incoming, maxBody);
+  if (body)
+    headers.set("content-length", String(body.length));
+  return new Request(new URL(incoming.url ?? "/", origin), { method, headers, ...body ? { body } : {} });
+}, "toRequest");
+var send = /* @__PURE__ */ __name(async (response, outgoing) => {
+  outgoing.writeHead(response.status, Object.fromEntries(response.headers));
+  if (!response.body)
+    return void outgoing.end();
+  const body = Readable.fromWeb(response.body);
+  outgoing.once("close", () => body.destroy());
+  body.pipe(outgoing);
+}, "send");
+var listen = /* @__PURE__ */ __name((handle, { host, port, maxBody = MAX_BODY }) => new Promise((resolve, reject) => {
+  const server = createServer((incoming, outgoing) => {
+    toRequest(incoming, `http://${host}`, maxBody).then(handle).then((response) => send(response, outgoing)).catch((error) => {
+      if (!outgoing.headersSent)
+        outgoing.writeHead(error instanceof TooLarge ? 413 : 500, { connection: "close" });
+      outgoing.end();
+    });
+  });
+  server.once("error", reject);
+  server.listen(port, host, () => {
+    const { port: bound } = server.address();
+    resolve({
+      url: new URL(`http://${host}:${bound}`),
+      close: /* @__PURE__ */ __name(() => new Promise((done) => {
+        server.close(() => done());
+        server.closeAllConnections();
+      }), "close")
+    });
+  });
+}), "listen");
+
+export {
+  listen
+};

package/dist/bundle/chunk-FZ5FXIG6.js

@@ -0,0 +1,18 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  resolvePaths
+} from "./chunk-J3QXTBD2.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/path.js
+import { join } from "node:path";
+var wirecatDirectory = /* @__PURE__ */ __name((env = process.env, platform) => resolvePaths({ appName: "WireCat", prefix: "WIRECAT", env, ...platform ? { platform } : {} }).state, "wirecatDirectory");
+var storePath = /* @__PURE__ */ __name((env = process.env) => env.MESSAGING_STORE ?? join(wirecatDirectory(env), "wirecat.db"), "storePath");
+
+export {
+  wirecatDirectory,
+  storePath
+};