@wirecat/zoom-cli 0.55.0 → 0.57.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-ZMCACJVS.js

@@ -0,0 +1,176 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  DefaultLogger,
+  DrizzleQueryError,
+  NoopLogger,
+  SQLiteAsyncDatabase,
+  SQLiteAsyncPreparedQuery,
+  SQLiteAsyncSession,
+  SQLiteAsyncTransaction,
+  SQLiteDialect,
+  booleanFromInteger,
+  bufferFromBytes,
+  castToText,
+  dateFromStoredMilliseconds,
+  dateFromStoredSeconds,
+  entityKind,
+  jitCompatCheck,
+  refineSqliteCodecs,
+  sql
+} from "./chunk-LY26NW3I.js";
+import {
+  __name
+} from "./chunk-ZVVMGPBJ.js";
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/store/sqlite/drizzle/node.js
+import { DatabaseSync } from "node:sqlite";
+var nodeSQLiteCodecs = refineSqliteCodecs({
+  "integer:boolean": { normalize: booleanFromInteger },
+  "integer:timestamp": { normalize: dateFromStoredSeconds },
+  "integer:timestamp_ms": { normalize: dateFromStoredMilliseconds },
+  "text:json": { normalize: JSON.parse },
+  blob: { normalize: bufferFromBytes },
+  "blob:json": {
+    cast: castToText,
+    normalize: JSON.parse
+  },
+  "blob:bigint": {
+    cast: castToText,
+    normalize: BigInt
+  },
+  numeric: {
+    cast: castToText,
+    normalize: String
+  },
+  "numeric:number": { normalize: Number },
+  "numeric:bigint": {
+    cast: castToText,
+    normalize: BigInt
+  }
+});
+var NodeSQLiteSession = class extends SQLiteAsyncSession {
+  static {
+    __name(this, "NodeSQLiteSession");
+  }
+  client;
+  relations;
+  options;
+  static [entityKind] = "SQLJsSession";
+  logger;
+  constructor(client, dialect, relations, options = {}) {
+    super(dialect, "sync");
+    this.client = client;
+    this.relations = relations;
+    this.options = options;
+    this.logger = options.logger ?? new NoopLogger();
+  }
+  prepareQuery(query, mode, _prepare, executeMethod, mapper, queryMetadata) {
+    let stmt;
+    try {
+      stmt = this.client.prepare(query.sql);
+    } catch (e) {
+      throw new DrizzleQueryError(query.sql, this.options.paramsInErrors ? query.params : void 0, e);
+    }
+    return new SQLiteAsyncPreparedQuery("sync", executeMethod, {
+      all: /* @__PURE__ */ __name((params) => {
+        stmt.setReturnArrays(mode === "arrays");
+        const res = stmt.all(...params);
+        if (mode === "objects") return res.map((row) => ({ ...row }));
+        return res;
+      }, "all"),
+      get: /* @__PURE__ */ __name((params) => {
+        stmt.setReturnArrays(mode === "arrays");
+        const res = stmt.get(...params);
+        if (res && mode === "objects") return { ...res };
+        return res;
+      }, "get"),
+      run: /* @__PURE__ */ __name((params) => {
+        stmt.setReturnArrays(false);
+        return stmt.run(...params);
+      }, "run")
+    }, query, mapper, mode, this.logger, void 0, queryMetadata, void 0, this.options.paramsInErrors);
+  }
+  transaction(transaction, config = {}) {
+    if (config?.behavior === "concurrent") throw new Error("Concurrent transactions are not supported by driver");
+    const tx = new NodeSQLiteTransaction("sync", this.dialect, this, this.relations);
+    this.run(sql.raw(`begin${config.behavior ? ` ${config.behavior}` : ""}`));
+    try {
+      const result = transaction(tx);
+      this.run(sql`commit`);
+      return result;
+    } catch (err) {
+      try {
+        this.run(sql`rollback`);
+      } catch {
+      }
+      throw err;
+    }
+  }
+};
+var NodeSQLiteTransaction = class NodeSQLiteTransaction2 extends SQLiteAsyncTransaction {
+  static {
+    __name(this, "NodeSQLiteTransaction2");
+  }
+  static [entityKind] = "SQLJsTransaction";
+  transaction(transaction) {
+    const savepointName = `sp${this.nestedIndex + 1}`;
+    const tx = new NodeSQLiteTransaction2("sync", this.dialect, this.session, this._.relations, this.nestedIndex + 1);
+    tx.run(sql.raw(`savepoint ${savepointName}`));
+    try {
+      const result = transaction(tx);
+      tx.run(sql.raw(`release savepoint ${savepointName}`));
+      return result;
+    } catch (err) {
+      try {
+        tx.run(sql.raw(`rollback to savepoint ${savepointName}`));
+      } catch {
+      }
+      throw err;
+    }
+  }
+};
+var NodeSQLiteDatabase = class extends SQLiteAsyncDatabase {
+  static {
+    __name(this, "NodeSQLiteDatabase");
+  }
+  static [entityKind] = "NodeSQLiteDatabase";
+};
+function construct(client, config = {}) {
+  const dialect = new SQLiteDialect({
+    codecs: config.codecs ?? nodeSQLiteCodecs,
+    useJitMappers: jitCompatCheck(config.jit)
+  });
+  let logger;
+  if (config.logger === true) logger = new DefaultLogger();
+  else if (config.logger !== false) logger = config.logger;
+  const relations = config.relations ?? {};
+  const db = new NodeSQLiteDatabase("sync", dialect, new NodeSQLiteSession(client, dialect, relations, {
+    logger,
+    paramsInErrors: config.paramsInErrors
+  }), relations);
+  db.$client = client;
+  return db;
+}
+__name(construct, "construct");
+function drizzle(...params) {
+  if (params[0] === void 0 || typeof params[0] === "string") return construct(params[0] === void 0 ? new DatabaseSync(":memory:") : new DatabaseSync(params[0]), params[1]);
+  const { connection, client, ...config } = params[0];
+  if (client) return construct(client, config);
+  if (typeof connection === "object") {
+    const { path, ...options } = connection;
+    return construct(new DatabaseSync(path ?? ":memory:", options), config);
+  }
+  return construct(new DatabaseSync(connection ?? ":memory:"), config);
+}
+__name(drizzle, "drizzle");
+(function(_drizzle) {
+  function mock(config) {
+    return construct({}, config);
+  }
+  __name(mock, "mock");
+  _drizzle.mock = mock;
+})(drizzle || (drizzle = {}));
+export {
+  drizzle
+};

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

@@ -0,0 +1,45 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  loadVectorExtension,
+  vectorExtension
+} from "./chunk-QTR6D5HT.js";
+import "./chunk-AE4BOXH7.js";
+import "./chunk-Y5E2WNWB.js";
+import {
+  __name
+} from "./chunk-ZVVMGPBJ.js";
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/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 cacheOverNodeSqlite = /* @__PURE__ */ __name((database) => {
+  return {
+    exec: /* @__PURE__ */ __name((sql) => database.exec(sql), "exec"),
+    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"),
+    close: /* @__PURE__ */ __name(() => database.close(), "close")
+  };
+}, "cacheOverNodeSqlite");
+export {
+  cacheOverNodeSqlite,
+  nodeClient,
+  openWithNodeSqlite
+};

package/dist/bundle/oauth-Q6LKF7DB.js

@@ -0,0 +1,17 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  ownerLogin,
+  revokeAll
+} from "./chunk-Z4TZ6TAF.js";
+import "./chunk-G4VZDINN.js";
+import "./chunk-5D4AEUVA.js";
+import "./chunk-4R7HYNZS.js";
+import "./chunk-PIN5RZ3D.js";
+import "./chunk-AE4BOXH7.js";
+import "./chunk-Y5E2WNWB.js";
+import "./chunk-ZVVMGPBJ.js";
+export {
+  ownerLogin,
+  revokeAll
+};

package/dist/bundle/open-LJ332Y5O.js

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

package/dist/bundle/output-file-RYQZ3RTE.js

@@ -0,0 +1,63 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  checkCancelled
+} from "./chunk-A4ETXPMZ.js";
+import "./chunk-LSVI3A5X.js";
+import {
+  CliError,
+  isCliError
+} from "./chunk-AE4BOXH7.js";
+import "./chunk-Y5E2WNWB.js";
+import {
+  __name
+} from "./chunk-ZVVMGPBJ.js";
+
+// dist/output-file.js
+import { randomUUID } from "node:crypto";
+import { link, open, unlink } from "node:fs/promises";
+var writeExportFile = /* @__PURE__ */ __name(async (path, content, options = {}) => {
+  checkCancelled(options.signal);
+  const temporary = `${path}.zm-${randomUUID()}.part`;
+  let handle;
+  let failure;
+  let failed = false;
+  try {
+    handle = await open(temporary, "wx", 384);
+    await handle.writeFile(content, "utf8");
+    await handle.sync();
+    checkCancelled(options.signal);
+    await link(temporary, path);
+  } catch (error) {
+    failed = true;
+    failure = error;
+  } finally {
+    if (handle) {
+      try {
+        await handle.close();
+      } catch (error) {
+        if (!failed) {
+          failed = true;
+          failure = error;
+        }
+      }
+      try {
+        await unlink(temporary);
+      } catch (error) {
+        if (!failed) {
+          failed = true;
+          failure = error;
+        }
+      }
+    }
+  }
+  if (!failed)
+    return;
+  if (isCliError(failure))
+    throw failure;
+  const code = typeof failure === "object" && failure !== null && "code" in failure ? failure.code : void 0;
+  throw new CliError(code === "EEXIST" ? "validation_error" : code === "EACCES" || code === "EPERM" ? "permission_error" : "configuration_error", code === "EEXIST" ? "output file already exists; choose another path" : "could not write the output file");
+}, "writeExportFile");
+export {
+  writeExportFile
+};

package/dist/bundle/process-ZPTLNVQS.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.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/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
+};