@wirecat/zoom-cli 0.56.0 → 0.58.0

package/dist/bundle/chunk-DXZTLB24.js

@@ -0,0 +1,120 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  array,
+  integer,
+  isoTime,
+  isoTimestamp,
+  minLength,
+  minValue,
+  nullable,
+  number,
+  optional,
+  picklist,
+  pipe,
+  record,
+  reference,
+  strictObject,
+  string,
+  unknown
+} from "./chunk-YIMI6O7R.js";
+
+// node_modules/.pnpm/@wirecat+cli-core@0.473.0_@wirecat+cli-base@0.65.0_commander@15.0.0_esbuild@0.28.2_type_39633e3162553a2c86dde989a9811fcb/node_modules/@wirecat/cli-core/dist/entities/fields.js
+var text = string();
+var id = pipe(string(), minLength(1));
+var time = isoTime;
+var zonedTime = pipe(string(), isoTimestamp("an ISO 8601 time with a zone"));
+var count = pipe(number(), integer(), minValue(0));
+var untrusted = optional(array(text));
+var providerMetadata = optional(record(string(), unknown()));
+var author = strictObject({
+  type: picklist(["person", "bot"]),
+  id,
+  name: nullable(text)
+});
+
+// node_modules/.pnpm/@wirecat+cli-core@0.473.0_@wirecat+cli-base@0.65.0_commander@15.0.0_esbuild@0.28.2_type_39633e3162553a2c86dde989a9811fcb/node_modules/@wirecat/cli-core/dist/entities/note.js
+var link = {
+  target_text: nullable(text),
+  kind: text,
+  anchor: nullable(text)
+};
+var note = strictObject({
+  ref: reference,
+  kind: optional(picklist(["note", "document"])),
+  provider: optional(text),
+  account: optional(text),
+  url: optional(text),
+  id,
+  source: picklist(["file", "internal"]),
+  folder_id: nullable(id),
+  path: nullable(text),
+  title: nullable(text),
+  text,
+  /** Raises on every edit; `notes edit --revision` takes it, so an edit made meanwhile is refused, not lost. */
+  revision: count,
+  /** A file's front matter as parsed, keys as the file writes them; null for a note without it. */
+  front_matter: nullable(record(string(), unknown())),
+  /** The hash of a file's bytes when last imported; null for a note written here. */
+  content_hash: nullable(text),
+  /** The file the note was exported to, where that is known; null otherwise. */
+  export_path: nullable(text),
+  created_at: time,
+  /** When the store's copy last changed. */
+  updated_at: time,
+  deleted_at: optional(nullable(time)),
+  tags: optional(array(text)),
+  /** The first line holding a word of a search. */
+  excerpt: optional(text),
+  /** Which halves of a search found it. */
+  found_by: optional(array(picklist(["title", "words", "meaning"]))),
+  /** What the note links to; `to` is null while the name written matches nothing stored. */
+  links: optional(array(strictObject({ to: nullable(reference), ...link }))),
+  /** The notes and messages that link to it. */
+  backlinks: optional(array(strictObject({ from: reference, ...link })))
+});
+
+// node_modules/.pnpm/@wirecat+cli-core@0.473.0_@wirecat+cli-base@0.65.0_commander@15.0.0_esbuild@0.28.2_type_39633e3162553a2c86dde989a9811fcb/node_modules/@wirecat/cli-core/dist/entities/knowledge-lists.js
+var organization = strictObject({
+  id,
+  ref: reference,
+  kind: picklist(["company", "team", "family", "community"]),
+  name: text,
+  scope: picklist(["personal", "work"]),
+  created_at: time
+});
+var project = strictObject({
+  id,
+  ref: reference,
+  key: text,
+  name: text,
+  kind: picklist(["project", "inbox"]),
+  type: picklist(["work", "client", "personal", "oss", "other"]),
+  organization_id: nullable(id),
+  scope: picklist(["personal", "work"]),
+  created_at: time
+});
+var reminder = strictObject({
+  id,
+  task: text,
+  due_at: time,
+  timezone: text,
+  state: picklist(["pending", "leased", "delivered", "cancelled"]),
+  revision: number(),
+  receipt: nullable(text)
+});
+
+export {
+  text,
+  id,
+  time,
+  zonedTime,
+  count,
+  untrusted,
+  providerMetadata,
+  author,
+  note,
+  organization,
+  project,
+  reminder
+};

package/dist/bundle/chunk-G27MRA24.js

@@ -0,0 +1,82 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  CliError
+} from "./chunk-YIMI6O7R.js";
+import {
+  __name
+} from "./chunk-ZVVMGPBJ.js";
+
+// node_modules/.pnpm/@wirecat+cli-core@0.473.0_@wirecat+cli-base@0.65.0_commander@15.0.0_esbuild@0.28.2_type_39633e3162553a2c86dde989a9811fcb/node_modules/@wirecat/cli-core/dist/cli/input-policy.js
+var MAX_BUFFERED_INPUT = 16 * 1024 * 1024;
+var MAX_SECRET_INPUT = 64 * 1024;
+var policies = /* @__PURE__ */ new WeakMap();
+var inputPolicy = /* @__PURE__ */ __name((input) => policies.get(input) ?? {}, "inputPolicy");
+var provideInputPolicy = /* @__PURE__ */ __name((input, policy) => {
+  const previous = policies.get(input);
+  policies.set(input, policy);
+  return () => {
+    if (previous)
+      policies.set(input, previous);
+    else
+      policies.delete(input);
+  };
+}, "provideInputPolicy");
+var bufferedInput = /* @__PURE__ */ __name((input, options = {}) => {
+  const policy = inputPolicy(input);
+  const maxBytes = options.maxBytes ?? policy.maxBytes ?? MAX_BUFFERED_INPUT;
+  const signals = [options.signal, policy.signal].filter((one) => one !== void 0);
+  const signal = signals.length ? AbortSignal.any(signals) : void 0;
+  const state = input;
+  if (state.readableEnded)
+    return Promise.resolve(Buffer.alloc(0));
+  if (state.destroyed)
+    return Promise.reject(new CliError("validation_error", "input closed before EOF", { reason: "input.closed" }));
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let bytes = 0;
+    const cleanup = /* @__PURE__ */ __name(() => {
+      input.off("data", data).off("end", end).off("error", error).off("close", closed);
+      signal?.removeEventListener("abort", aborted);
+      input.pause();
+    }, "cleanup");
+    const error = /* @__PURE__ */ __name((cause) => {
+      cleanup();
+      reject(cause);
+    }, "error");
+    const aborted = /* @__PURE__ */ __name(() => error(new CliError("cancelled", "input cancelled", { retryable: false })), "aborted");
+    const closed = /* @__PURE__ */ __name(() => error(new CliError("validation_error", "input closed before EOF", { reason: "input.closed" })), "closed");
+    const end = /* @__PURE__ */ __name(() => {
+      cleanup();
+      resolve(Buffer.concat(chunks, bytes));
+    }, "end");
+    const data = /* @__PURE__ */ __name((chunk) => {
+      const buffer = Buffer.from(chunk);
+      bytes += buffer.length;
+      if (bytes > maxBytes) {
+        error(new CliError("validation_error", `buffered input exceeds ${maxBytes} bytes \u2014 use a smaller input or --max-input-bytes`, {
+          reason: "input.too-large",
+          max_bytes: maxBytes,
+          retryable: false
+        }));
+        return;
+      }
+      chunks.push(buffer);
+    }, "data");
+    if (signal?.aborted) {
+      aborted();
+      return;
+    }
+    input.on("data", data).once("end", end).once("error", error).once("close", closed);
+    signal?.addEventListener("abort", aborted, { once: true });
+    input.resume();
+  });
+}, "bufferedInput");
+
+export {
+  MAX_BUFFERED_INPUT,
+  MAX_SECRET_INPUT,
+  inputPolicy,
+  provideInputPolicy,
+  bufferedInput
+};