@wirecat/zoom-cli 0.56.0 → 0.58.0

package/dist/bundle/chunk-7Z4ANTAK.js

@@ -0,0 +1,1095 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  count,
+  id,
+  text,
+  time
+} from "./chunk-DXZTLB24.js";
+import {
+  filesPresent,
+  sharedModelsDirectory
+} from "./chunk-6FL25KC5.js";
+import {
+  TASK_ORIGINS,
+  TASK_STATES,
+  TASK_TYPES
+} from "./chunk-CTGI4ES2.js";
+import {
+  TAG_TYPES
+} from "./chunk-MMT46EN4.js";
+import {
+  CliError,
+  array,
+  boolean,
+  createRecordLog,
+  isCliError,
+  nullable,
+  number,
+  optional,
+  picklist,
+  reference,
+  resolvePaths,
+  strictObject,
+  traceIdOf,
+  writeSecurely
+} 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/runs/run.js
+import { randomUUID } from "node:crypto";
+import { appendFileSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { userInfo } from "node:os";
+import { join, sep } from "node:path";
+
+// 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/runs/log-keys.js
+var snake = /* @__PURE__ */ __name((key) => key.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`), "snake");
+var camel = /* @__PURE__ */ __name((key) => key.replace(/_([a-z0-9])/g, (_, letter) => letter.toUpperCase()), "camel");
+var renamed = /* @__PURE__ */ __name((record, name) => Object.fromEntries(Object.entries(record).map(([key, value]) => [name(key), value])), "renamed");
+var logAttributes = /* @__PURE__ */ __name((event) => renamed(event, snake), "logAttributes");
+var fromLogAttributes = /* @__PURE__ */ __name((attributes) => renamed(attributes, camel), "fromLogAttributes");
+var snakeLogger = /* @__PURE__ */ __name((logger) => ({
+  debug: /* @__PURE__ */ __name((event, message) => logger.debug(logAttributes(event), message), "debug"),
+  info: /* @__PURE__ */ __name((event, message) => logger.info(logAttributes(event), message), "info"),
+  warn: /* @__PURE__ */ __name((event, message) => logger.warn(logAttributes(event), message), "warn"),
+  error: /* @__PURE__ */ __name((event, message) => logger.error(logAttributes(event), message), "error")
+}), "snakeLogger");
+
+// 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/runs/log-attributes.js
+var diagnostic = {
+  event: true,
+  operation: true,
+  opcode: true,
+  seq: true,
+  status: true,
+  method: true,
+  endpointTemplate: true,
+  bytes: true,
+  ids: true,
+  counts: true,
+  durationMs: true,
+  outcome: true,
+  errorCode: true,
+  providerError: true,
+  level: true,
+  transport: true,
+  attempt: true,
+  waitMs: true,
+  code: true,
+  detail: true,
+  reason: true,
+  ageMs: true
+};
+var send = {
+  profile: true,
+  chatId: true,
+  outcome: true,
+  kind: true,
+  action: true,
+  people: true,
+  messageId: true,
+  key: true,
+  count: true,
+  forEveryone: true,
+  sendId: true,
+  operationId: true,
+  parentOperationId: true,
+  replyTo: true,
+  threadId: true,
+  sendAs: true,
+  resultChatId: true,
+  length: true,
+  attachments: true,
+  scheduledFor: true,
+  notify: true,
+  origin: true,
+  reservation: true,
+  errorCode: true
+};
+var background = [
+  "job",
+  "pid",
+  "schedule",
+  "exitCode",
+  "tool",
+  "tier",
+  "actorType",
+  "actorId",
+  "agent",
+  "targetType",
+  "targetId"
+];
+var crash = ["errorClass", "frames"];
+var dropped = ["dropped"];
+var LOG_ATTRIBUTES = [
+  ...new Set([...Object.keys(diagnostic), ...Object.keys(send), ...background, ...crash, ...dropped].map((key) => Object.keys(logAttributes({ [key]: true }))[0]))
+].sort();
+
+// 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/runs/run.js
+var KEEP_RUNS_FOR_DAYS = 30;
+var KEEP_SUCCESSFUL_RUNS_FOR_DAYS = 7;
+var RUNS_SIZE_LIMIT_MB = 200;
+var runsDirFor = /* @__PURE__ */ __name((app, env = process.env) => join(resolvePaths({ appName: app.appName, prefix: app.envPrefix, env }).state, "runs"), "runsDirFor");
+var startRun = /* @__PURE__ */ __name((options) => {
+  const now = options.now ?? (() => /* @__PURE__ */ new Date());
+  const startedAt = options.startedAt ?? now();
+  const id2 = options.runId ?? newRunId(startedAt, options.command);
+  const dir = join(options.runsDir, day(startedAt), id2);
+  pruneRuns(options.runsDir, {
+    keepDays: options.keepDays ?? KEEP_RUNS_FOR_DAYS,
+    keepSuccessDays: options.keepSuccessDays ?? KEEP_SUCCESSFUL_RUNS_FOR_DAYS,
+    maxBytes: options.maxBytes ?? RUNS_SIZE_LIMIT_MB * 1024 * 1024,
+    now: startedAt
+  });
+  refuseRealStateInTests(dir);
+  const metadata = {
+    runId: id2,
+    command: options.command,
+    ...options.profile === void 0 ? {} : { profile: options.profile },
+    startedAt: startedAt.toISOString(),
+    status: "running",
+    cliVersion: options.cliVersion,
+    runtime: runtime(),
+    platform: process.platform,
+    arch: process.arch,
+    ...options.traceId === void 0 ? {} : { traceId: options.traceId },
+    ...options.context
+  };
+  let file;
+  const opened = /* @__PURE__ */ __name(() => {
+    if (file)
+      return file;
+    mkdirSync(dir, { recursive: true, mode: 448 });
+    const events = join(dir, "events.jsonl");
+    writeFileSync(events, "", { flag: "a", mode: 384 });
+    file = snakeLogger(createRecordLog({
+      to: events,
+      runId: id2,
+      command: options.command,
+      resource: { service: options.service, version: options.cliVersion },
+      allow: LOG_ATTRIBUTES,
+      ...options.traceId === void 0 ? {} : { traceId: options.traceId },
+      ...options.onError === void 0 ? {} : { onError: options.onError }
+    }));
+    writeRunFile(dir, metadata);
+    return file;
+  }, "opened");
+  if (!options.lazy)
+    opened();
+  let finished = false;
+  const operations = /* @__PURE__ */ new Set();
+  const codes = /* @__PURE__ */ new Set();
+  const noted = /* @__PURE__ */ __name((level) => (event, message) => {
+    const { operation, errorCode, error_code, code } = event;
+    if (typeof operation === "string")
+      operations.add(operation);
+    for (const value of [errorCode, error_code, code])
+      if (typeof value === "string")
+        codes.add(value);
+    if (finished)
+      return;
+    opened()[level](event, message);
+  }, "noted");
+  const logger = { debug: noted("debug"), info: noted("info"), warn: noted("warn"), error: noted("error") };
+  return {
+    id: id2,
+    dir,
+    logger,
+    finish: /* @__PURE__ */ __name(async (status, extra = {}) => {
+      if (finished)
+        return;
+      finished = true;
+      const completedAt = now();
+      const final = {
+        ...metadata,
+        ...extra,
+        status,
+        completedAt: completedAt.toISOString(),
+        durationMs: completedAt.getTime() - startedAt.getTime(),
+        operations: [...operations].sort(),
+        codes: [...codes].sort()
+      };
+      if (file || status !== "success") {
+        opened();
+        writeRunFile(dir, final);
+        return;
+      }
+      try {
+        mkdirSync(join(dir, ".."), { recursive: true, mode: 448 });
+        appendIndex(join(dir, ".."), runFileOf(final));
+      } catch (error) {
+        options.onError?.(error);
+      }
+    }, "finish")
+  };
+}, "startRun");
+var refuseRealStateInTests = /* @__PURE__ */ __name((dir, env = process.env) => {
+  if (env.VITEST === void 0)
+    return;
+  let home;
+  try {
+    home = userInfo().homedir;
+  } catch {
+    return;
+  }
+  if (dir.startsWith(join(home, ".local", "share") + sep))
+    throw new Error(`a test opened a run in the real data folder: ${dir}`);
+}, "refuseRealStateInTests");
+var runtime = /* @__PURE__ */ __name(() => {
+  const bun = process.versions.bun;
+  return bun ? `bun ${bun}` : `node ${process.versions.node}`;
+}, "runtime");
+var newRunId = /* @__PURE__ */ __name((startedAt, command) => {
+  const stamp = startedAt.toISOString().replace(/[-:]/g, "").replace(/\.\d+Z$/, "Z");
+  const slug = command.replace(/[^a-z0-9]+/gi, "-").toLowerCase();
+  return `${stamp}-${slug}-${randomUUID().slice(0, 6)}`;
+}, "newRunId");
+var INDEX = "index.jsonl";
+var appendIndex = /* @__PURE__ */ __name((dayDir, written) => {
+  appendFileSync(join(dayDir, INDEX), `${JSON.stringify(written)}
+`, { mode: 384 });
+}, "appendIndex");
+var writeRunFile = /* @__PURE__ */ __name((dir, metadata) => {
+  const written = runFileOf(metadata);
+  writeSecurely(join(dir, "run.json"), `${JSON.stringify(written, null, 2)}
+`, 384);
+  try {
+    appendIndex(join(dir, ".."), written);
+  } catch {
+  }
+}, "writeRunFile");
+var matchesListFilter = /* @__PURE__ */ __name((run, filter) => (filter.runId === void 0 || run.runId === filter.runId) && (filter.command === void 0 || run.command === filter.command) && (filter.profile === void 0 || run.profile === filter.profile) && (filter.status === void 0 || run.status === filter.status) && (filter.errorCode === void 0 || run.errorCode === filter.errorCode), "matchesListFilter");
+var listRuns = /* @__PURE__ */ __name((runsDir, { since, atLeast = Number.POSITIVE_INFINITY, filter = {} } = {}) => {
+  const first = since === void 0 ? void 0 : day(new Date(since));
+  const runs = [];
+  for (const date of days(runsDir).sort().reverse()) {
+    if (first !== void 0 && date < first || runs.length >= atLeast)
+      break;
+    for (const metadata of runsOfDay(join(runsDir, date))) {
+      if (matchesListFilter(metadata, filter))
+        runs.push(metadata);
+    }
+  }
+  return runs;
+}, "listRuns");
+var indexedRuns = /* @__PURE__ */ __name((dayDir) => {
+  const latest = /* @__PURE__ */ new Map();
+  let raw = "";
+  try {
+    raw = readFileSync(join(dayDir, INDEX), "utf8");
+  } catch {
+  }
+  for (const line of raw.split("\n")) {
+    if (line.trim() === "")
+      continue;
+    try {
+      const metadata = metadataOf(JSON.parse(line));
+      if (typeof metadata.runId === "string")
+        latest.set(metadata.runId, metadata);
+    } catch {
+    }
+  }
+  return latest;
+}, "indexedRuns");
+var runsOfDay = /* @__PURE__ */ __name((dayDir) => {
+  const latest = indexedRuns(dayDir);
+  for (const entry of safeReaddir(dayDir)) {
+    if (entry === INDEX || entry.startsWith(".") || latest.has(entry))
+      continue;
+    const metadata = readRun(join(dayDir, entry));
+    if (metadata)
+      latest.set(metadata.runId, metadata);
+  }
+  return [...latest.values()].sort((a, b) => a.runId < b.runId ? 1 : a.runId > b.runId ? -1 : 0);
+}, "runsOfDay");
+var findRun = /* @__PURE__ */ __name((runsDir, id2) => {
+  const stamped = /^(\d{4})(\d{2})(\d{2})T/.exec(id2);
+  const likely = stamped ? [`${stamped[1]}-${stamped[2]}-${stamped[3]}`] : [];
+  const dates = [.../* @__PURE__ */ new Set([...likely, ...days(runsDir)])];
+  for (const date of dates) {
+    const dir = join(runsDir, date, id2);
+    const metadata = readRun(dir);
+    if (metadata)
+      return { dir, metadata };
+  }
+  for (const date of dates) {
+    const metadata = indexedRuns(join(runsDir, date)).get(id2);
+    if (metadata)
+      return { dir: join(runsDir, date, id2), metadata };
+  }
+  return void 0;
+}, "findRun");
+var readEvents = /* @__PURE__ */ __name((dir) => {
+  let raw;
+  try {
+    raw = readFileSync(join(dir, "events.jsonl"), "utf8");
+  } catch {
+    return [];
+  }
+  const events = [];
+  for (const line of raw.split("\n")) {
+    if (line.trim() === "")
+      continue;
+    try {
+      const parsed = JSON.parse(line);
+      if (parsed !== null && typeof parsed === "object")
+        events.push(eventOf(parsed));
+    } catch {
+    }
+  }
+  return events;
+}, "readEvents");
+var eventOf = /* @__PURE__ */ __name((line) => {
+  const { attributes, time: time2, severity } = line;
+  if (attributes === null || typeof attributes !== "object")
+    return logAttributes(line);
+  return { time: time2, severity, ...logAttributes(attributes) };
+}, "eventOf");
+var pruneRuns = /* @__PURE__ */ __name((runsDir, { keepDays, keepSuccessDays = keepDays, maxBytes, now }) => {
+  const cutoff = day(new Date(now.getTime() - keepDays * DAY_MS));
+  const successCutoff = day(new Date(now.getTime() - Math.min(keepSuccessDays, keepDays) * DAY_MS));
+  let removed = 0;
+  for (const date of days(runsDir)) {
+    if (date >= cutoff) {
+      if (date < successCutoff)
+        dropSuccesses(join(runsDir, date));
+      continue;
+    }
+    try {
+      rmSync(join(runsDir, date), { recursive: true, force: true });
+      removed += 1;
+    } catch {
+    }
+  }
+  if (maxBytes !== void 0)
+    removed += fitSize(runsDir, maxBytes, now);
+  return removed;
+}, "pruneRuns");
+var DAY_MS = 24 * 60 * 60 * 1e3;
+var SUCCESSES_DROPPED = ".successes-dropped";
+var SIZE_CHECKED = ".size-checked";
+var dropSuccesses = /* @__PURE__ */ __name((dayDir) => {
+  const marker = join(dayDir, SUCCESSES_DROPPED);
+  try {
+    statSync(marker);
+    return;
+  } catch {
+  }
+  try {
+    const kept = [];
+    for (const [id2, metadata] of indexedRuns(dayDir)) {
+      if (metadata.status === "success")
+        rmSync(join(dayDir, id2), { recursive: true, force: true });
+      else
+        kept.push(JSON.stringify(runFileOf(metadata)));
+    }
+    for (const entry of safeReaddir(dayDir)) {
+      if (entry === INDEX || entry.startsWith("."))
+        continue;
+      if (readRun(join(dayDir, entry))?.status === "success")
+        rmSync(join(dayDir, entry), { recursive: true, force: true });
+    }
+    writeSecurely(join(dayDir, INDEX), kept.map((line) => `${line}
+`).join(""), 384);
+    writeFileSync(marker, "", { mode: 384 });
+  } catch {
+  }
+}, "dropSuccesses");
+var sizeOf = /* @__PURE__ */ __name((path) => {
+  let total = 0;
+  for (const entry of safeReaddir(path)) {
+    const full = join(path, entry);
+    try {
+      const stat = statSync(full);
+      total += stat.isDirectory() ? sizeOf(full) : stat.size;
+    } catch {
+    }
+  }
+  return total;
+}, "sizeOf");
+var fitSize = /* @__PURE__ */ __name((runsDir, maxBytes, now) => {
+  const stamp = join(runsDir, SIZE_CHECKED);
+  const today = day(now);
+  try {
+    if (readFileSync(stamp, "utf8").trim() === today)
+      return 0;
+  } catch {
+  }
+  const dates = days(runsDir).sort();
+  const sizes = new Map(dates.map((date) => [date, sizeOf(join(runsDir, date))]));
+  let total = [...sizes.values()].reduce((sum, size) => sum + size, 0);
+  let removed = 0;
+  for (const date of dates) {
+    if (total <= maxBytes || date === today)
+      break;
+    dropSuccesses(join(runsDir, date));
+    const after = sizeOf(join(runsDir, date));
+    total -= (sizes.get(date) ?? 0) - after;
+    sizes.set(date, after);
+  }
+  for (const date of dates) {
+    if (total <= maxBytes || date === today)
+      break;
+    try {
+      rmSync(join(runsDir, date), { recursive: true, force: true });
+      total -= sizes.get(date) ?? 0;
+      removed += 1;
+    } catch {
+    }
+  }
+  try {
+    mkdirSync(runsDir, { recursive: true, mode: 448 });
+    writeFileSync(stamp, today, { mode: 384 });
+  } catch {
+  }
+  return removed;
+}, "fitSize");
+var day = /* @__PURE__ */ __name((date) => date.toISOString().slice(0, 10), "day");
+var days = /* @__PURE__ */ __name((runsDir) => safeReaddir(runsDir).filter((entry) => /^\d{4}-\d{2}-\d{2}$/.test(entry)), "days");
+var readRun = /* @__PURE__ */ __name((dir) => {
+  try {
+    return metadataOf(JSON.parse(readFileSync(join(dir, "run.json"), "utf8")));
+  } catch {
+    return void 0;
+  }
+}, "readRun");
+var safeReaddir = /* @__PURE__ */ __name((dir) => {
+  try {
+    return readdirSync(dir);
+  } catch {
+    return [];
+  }
+}, "safeReaddir");
+var runFileOf = /* @__PURE__ */ __name(({ partial, ...metadata }) => ({
+  ...logAttributes(metadata),
+  ...partial ? { partial: { ...logAttributes(partial), failures: partial.failures.map((failure) => logAttributes(failure)) } } : {}
+}), "runFileOf");
+var metadataOf = /* @__PURE__ */ __name((parsed) => {
+  const { partial, ...metadata } = fromLogAttributes(parsed);
+  if (partial === null || typeof partial !== "object")
+    return metadata;
+  const { failures, ...rest } = fromLogAttributes(partial);
+  return {
+    ...metadata,
+    partial: {
+      ...rest,
+      failures: Array.isArray(failures) ? failures.map((failure) => fromLogAttributes(failure)) : []
+    }
+  };
+}, "metadataOf");
+
+// 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/runs/scope.js
+import { AsyncLocalStorage } from "node:async_hooks";
+import { randomBytes } from "node:crypto";
+var scopes = new AsyncLocalStorage();
+var processScope;
+var currentRun = /* @__PURE__ */ __name(() => {
+  const scope = scopes.getStore();
+  if (scope)
+    return scope;
+  processScope ??= {
+    runId: newRunId(/* @__PURE__ */ new Date(), "process"),
+    command: "",
+    startedAt: Date.now(),
+    ...traceOf(process.env)
+  };
+  return processScope;
+}, "currentRun");
+var inRun = /* @__PURE__ */ __name((scope, body) => scopes.run(scope, body), "inRun");
+var runEvent = /* @__PURE__ */ __name((event) => scopes.getStore()?.events?.(event), "runEvent");
+var typedCommand = /* @__PURE__ */ __name((tool, words, profile = currentRun().profile) => [tool, profile, words].filter((part) => part !== void 0 && part !== "").join(" "), "typedCommand");
+var useAsProcessRun = /* @__PURE__ */ __name((scope) => {
+  processScope = scope;
+}, "useAsProcessRun");
+var processRun = /* @__PURE__ */ __name(() => processScope, "processRun");
+var enclosingTraceId = /* @__PURE__ */ __name(() => scopes.getStore()?.traceId, "enclosingTraceId");
+var traceOf = /* @__PURE__ */ __name((env) => {
+  const traceId = traceIdOf(env.TRACEPARENT);
+  return traceId === void 0 ? {} : { traceId };
+}, "traceOf");
+var childTrace = /* @__PURE__ */ __name(() => {
+  const hex = /* @__PURE__ */ __name((bytes) => randomBytes(bytes).toString("hex"), "hex");
+  const traceId = hex(16);
+  return { traceId, traceparent: `00-${traceId}-${hex(8)}-01` };
+}, "childTrace");
+var attempts = new AsyncLocalStorage();
+var withAttempt = /* @__PURE__ */ __name((attempt, work) => attempts.run(attempt, work), "withAttempt");
+var currentAttempt = /* @__PURE__ */ __name(() => attempts.getStore(), "currentAttempt");
+
+// 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/domain/duration.js
+var DURATION = /^(\d+)(ms|s|m|h|d)$/;
+var UNIT_MS = { ms: 1, s: 1e3, m: 6e4, h: 36e5, d: 864e5 };
+var parseDuration = /* @__PURE__ */ __name((value, source) => {
+  const match = DURATION.exec(value.trim());
+  if (!match?.[1] || !match[2]) {
+    throw new CliError("validation_error", `${source} takes a duration with a unit \u2014 500ms, 30s, 2m, 4h or 1d \u2014 not "${value}"`);
+  }
+  const ms = Number(match[1]) * (UNIT_MS[match[2]] ?? 0);
+  if (ms <= 0)
+    throw new CliError("validation_error", `${source} has to be more than zero, and "${value}" is not`);
+  return ms;
+}, "parseDuration");
+
+// 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/sends/guarded.js
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
+var sentIds = /* @__PURE__ */ __name((typed, message) => ({
+  messageId: message.id,
+  ...message.chatId && message.chatId !== typed ? { resultChatId: message.chatId } : {}
+}), "sentIds");
+var current = new AsyncLocalStorage2();
+var writesInFlight = new AsyncLocalStorage2();
+var parents = /* @__PURE__ */ new WeakMap();
+var stopped = /* @__PURE__ */ new WeakMap();
+var scopesFor = /* @__PURE__ */ __name((scope = writesInFlight.getStore()) => {
+  const result = [];
+  for (let at = scope; at; at = parents.get(at))
+    result.push(at);
+  return result;
+}, "scopesFor");
+var withWriteScope = /* @__PURE__ */ __name((scope, body) => {
+  const parent = writesInFlight.getStore();
+  if (parent && parent !== scope)
+    parents.set(scope, parent);
+  return writesInFlight.run(scope, body);
+}, "withWriteScope");
+var stopWrites = /* @__PURE__ */ __name((scope, reason) => {
+  stopped.set(scope, reason);
+  for (const write of scope)
+    write.cut();
+}, "stopWrites");
+var refuseStopped = /* @__PURE__ */ __name((scopes2) => {
+  for (const scope of scopes2)
+    if (stopped.has(scope))
+      throw stopped.get(scope);
+}, "refuseStopped");
+var currentOperation = /* @__PURE__ */ __name(() => current.getStore(), "currentOperation");
+var guardedWrite = /* @__PURE__ */ __name(async (guard, attempt, act, settled = () => ({}), prepare) => {
+  const scopes2 = scopesFor();
+  refuseStopped(scopes2);
+  try {
+    await guard.ask?.(attempt);
+    refuseStopped(scopes2);
+    if (guard.reserve) {
+      guard.check(attempt, { reserve: false });
+      await guard.reserve(attempt);
+    } else
+      guard.check(attempt);
+  } catch (error) {
+    guard.record({ ...attempt, outcome: "refused", errorCode: codeOf(error) });
+    throw error;
+  }
+  try {
+    refuseStopped(scopes2);
+  } catch (error) {
+    guard.record({ ...attempt, outcome: "failed", errorCode: codeOf(error) });
+    throw error;
+  }
+  let recorded = false;
+  const once = /* @__PURE__ */ __name((entry) => {
+    if (recorded)
+      return;
+    recorded = true;
+    guard.record(entry);
+  }, "once");
+  let cancelled = false;
+  const flight = {
+    operationId: attempt.operationId,
+    preparing: prepare !== void 0,
+    cut: /* @__PURE__ */ __name(() => {
+      cancelled = true;
+      once({
+        ...attempt,
+        outcome: flight.preparing ? "failed" : "outcome_unknown",
+        errorCode: flight.preparing ? "timeout" : "outcome_unknown"
+      });
+    }, "cut")
+  };
+  for (const scope of scopes2)
+    scope.add(flight);
+  try {
+    if (prepare !== void 0)
+      await prepare();
+    if (cancelled)
+      throw new CliError("timeout", "the command ended before sending; nothing was sent", { sent: false });
+    flight.preparing = false;
+    const done = await current.run(attempt.operationId, act);
+    if (cancelled)
+      throw new CliError("outcome_unknown", "the command ended with a write in flight; check its result before continuing", { operation_id: attempt.operationId });
+    once({ ...attempt, ...settled(done), outcome: "sent" });
+    return done;
+  } catch (error) {
+    const code = codeOf(error);
+    once({ ...attempt, outcome: code === "outcome_unknown" ? "outcome_unknown" : "failed", errorCode: code });
+    if (code === "outcome_unknown" && error instanceof Error)
+      throw new CliError("outcome_unknown", error.message, {
+        ...error.details,
+        operation_id: attempt.operationId,
+        retryable: false
+      });
+    if (flight.preparing && isCliError(error) && error.details.sent === void 0)
+      throw new CliError(error.code, error.message, { ...error.details, sent: false });
+    throw error;
+  } finally {
+    for (const scope of scopes2)
+      scope.delete(flight);
+  }
+}, "guardedWrite");
+var codeOf = /* @__PURE__ */ __name((error) => typeof error?.code === "string" ? error.code : "unknown", "codeOf");
+
+// 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/embeddings/models.js
+var huggingFace = /* @__PURE__ */ __name((repository, commit) => (name) => `https://huggingface.co/${repository}/resolve/${commit}/${name}`, "huggingFace");
+var e5 = huggingFace("Xenova/multilingual-e5-small", "761b726dd34fb83930e26aab4e9ac3899aa1fa78");
+var gemma = huggingFace("onnx-community/embeddinggemma-300m-ONNX", "5090578d9565bb06545b4552f76e6bc2c93e4a66");
+var TEXT_MODELS = [
+  {
+    id: "e5-small",
+    title: "multilingual-e5-small, 8-bit",
+    languages: "about 100 languages, Russian and English among them",
+    licence: "MIT",
+    dims: 384,
+    maxTokens: 512,
+    // 100k-message corpus, one 8-thread session on Ryzen AI 9 HX 470: 31–32 chunks/s.
+    chunksPerSecond: 31,
+    pooling: "mean",
+    prefix: { query: "query: ", passage: "passage: " },
+    onnx: "onnx/model_quantized.onnx",
+    files: [
+      {
+        name: "onnx/model_quantized.onnx",
+        url: e5("onnx/model_quantized.onnx"),
+        sha256: "f80102d3f2a1229f387d3c81909990d8945513e347b0eab049f7de3c6f98c193",
+        bytes: 118308185
+      },
+      {
+        name: "tokenizer.json",
+        url: e5("tokenizer.json"),
+        sha256: "0b44a9d7b51c3c62626640cda0e2c2f70fdacdc25bbbd68038369d14ebdf4c39",
+        bytes: 17082730
+      },
+      {
+        name: "tokenizer_config.json",
+        url: e5("tokenizer_config.json"),
+        sha256: "a1d6bc8734a6f635dc158508bef000f8e2e5a759c7d92f984b2c86e5ff53425b",
+        bytes: 443
+      }
+    ]
+  },
+  {
+    id: "embeddinggemma",
+    title: "EmbeddingGemma 300M, 4-bit",
+    languages: "over 100 languages \u2014 the best of the two on chat, about seven times slower",
+    licence: "Gemma Terms of Use",
+    terms: "https://ai.google.dev/gemma/terms",
+    dims: 768,
+    maxTokens: 2048,
+    chunksPerSecond: 2,
+    pooling: "sentence_embedding",
+    prefix: { query: "task: search result | query: ", passage: "title: none | text: " },
+    onnx: "onnx/model_q4.onnx",
+    externalData: "onnx/model_q4.onnx_data",
+    files: [
+      {
+        name: "onnx/model_q4.onnx",
+        url: gemma("onnx/model_q4.onnx"),
+        sha256: "ad1dfee81a70f7944b9b9d1cc6e48075b832881cf33fab2f2b248be78f3f0043",
+        bytes: 519322
+      },
+      {
+        name: "onnx/model_q4.onnx_data",
+        url: gemma("onnx/model_q4.onnx_data"),
+        sha256: "599962c3143b040de2dd05e5975be3e9091dd067cacc6a8f7186e3203bab9e02",
+        bytes: 196725760
+      },
+      {
+        name: "tokenizer.json",
+        url: gemma("tokenizer.json"),
+        sha256: "4dda02faaf32bc91031dc8c88457ac272b00c1016cc679757d1c441b248b9c47",
+        bytes: 20323312
+      },
+      {
+        name: "tokenizer_config.json",
+        url: gemma("tokenizer_config.json"),
+        sha256: "3ca953eea6c3c9fcda9cf3df22949ff18b216f7c74bd6459230f3f1013953f3a",
+        bytes: 1156830
+      }
+    ]
+  }
+];
+var DEFAULT_TEXT_MODEL = "e5-small";
+var textModel = /* @__PURE__ */ __name((id2) => {
+  const found = TEXT_MODELS.find((model) => model.id === id2);
+  if (!found) {
+    throw new CliError("validation_error", `no text model ${id2} \u2014 one of: ${TEXT_MODELS.map((model) => model.id).join(", ")}`);
+  }
+  return found;
+}, "textModel");
+var mmarco = huggingFace("cross-encoder/mmarco-mMiniLMv2-L12-H384-v1", "1427fd652930e4ba29e8149678df786c240d8825");
+var bge = huggingFace("onnx-community/bge-reranker-v2-m3-ONNX", "6f5ff65298512715a1e669753bc754d2bc8f367b");
+var RERANK_MODELS = [
+  {
+    id: "mmarco",
+    title: "mMARCO mMiniLMv2-L12 cross-encoder, 8-bit",
+    languages: "about 100 languages, Russian and English among them",
+    licence: "Apache-2.0",
+    maxTokens: 512,
+    // The x86 name is the quantizer's target; WebAssembly and native ONNX Runtime both run it on any processor.
+    onnx: "onnx/model_quint8_avx2.onnx",
+    files: [
+      {
+        name: "onnx/model_quint8_avx2.onnx",
+        url: mmarco("onnx/model_quint8_avx2.onnx"),
+        sha256: "6c2513767fb63d008a4377bef7a7a3555433d9436342bb53e35a3a72ffc52d4b",
+        bytes: 118620016
+      },
+      {
+        name: "tokenizer.json",
+        url: mmarco("tokenizer.json"),
+        sha256: "62c24cdc13d4c9952d63718d6c9fa4c287974249e16b7ade6d5a85e7bbb75626",
+        bytes: 17082660
+      },
+      {
+        name: "tokenizer_config.json",
+        url: mmarco("tokenizer_config.json"),
+        sha256: "e7fbfbfa6347b4e414c1cee50d142e2c2f9a895dad68b068ae83a8b564c3837e",
+        bytes: 435
+      }
+    ]
+  },
+  {
+    id: "bge-reranker-v2-m3",
+    title: "BGE reranker v2 m3, 8-bit",
+    languages: "over 100 languages \u2014 better than mmarco in the benchmark, about seven times slower",
+    licence: "Apache-2.0 (BAAI's; the ONNX export declares none)",
+    maxTokens: 512,
+    onnx: "onnx/model_quantized.onnx",
+    files: [
+      {
+        name: "onnx/model_quantized.onnx",
+        url: bge("onnx/model_quantized.onnx"),
+        sha256: "912fc1215c2dbff6499700534bd8d31253af01573861abbfc43afd1fab6cce5d",
+        bytes: 570727094
+      },
+      {
+        name: "tokenizer.json",
+        url: bge("tokenizer.json"),
+        sha256: "8bf8afbfd11306bd872018c53bfdf2e160a56f8edbcf49933324404791c148d3",
+        bytes: 17082900
+      },
+      {
+        name: "tokenizer_config.json",
+        url: bge("tokenizer_config.json"),
+        sha256: "b87c8703482b0300d3da30e201519aa641f6a450f5eb5bf1e624afbf70c74d80",
+        bytes: 1203
+      }
+    ]
+  }
+];
+var DEFAULT_RERANK_MODEL = "mmarco";
+var rerankModel = /* @__PURE__ */ __name((id2) => {
+  const found = RERANK_MODELS.find((model) => model.id === id2);
+  if (!found) {
+    throw new CliError("validation_error", `no reranker ${id2} \u2014 one of: ${RERANK_MODELS.map((model) => model.id).join(", ")}`);
+  }
+  return found;
+}, "rerankModel");
+var vectorModelKey = /* @__PURE__ */ __name((model) => `local:${model.id}:${model.dims}`, "vectorModelKey");
+var meaningFloor = /* @__PURE__ */ __name((key) => key === "local:e5-small:384" ? 0.8 : 0, "meaningFloor");
+
+// 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/images/picture/models.js
+import { join as join2 } from "node:path";
+var clip = /* @__PURE__ */ __name((name) => `https://huggingface.co/Xenova/clip-vit-base-patch32/resolve/d15189d7028b43f1d3e65039190477f6af591c2a/${name}`, "clip");
+var IMAGE_MODELS = [
+  {
+    id: "clip-b32",
+    title: "CLIP ViT-B/32, 8-bit",
+    languages: "English only: translate a query before searching",
+    licence: "MIT",
+    dims: 512,
+    key: "local:clip-b32:512",
+    maxTokens: 77,
+    vision: "onnx/vision_model_quantized.onnx",
+    text: "onnx/text_model_quantized.onnx",
+    files: [
+      {
+        name: "onnx/vision_model_quantized.onnx",
+        url: clip("onnx/vision_model_quantized.onnx"),
+        sha256: "583fd1110a514667812fee7d684952aaf82a99b959760c8d7dca7e0ab9839299",
+        bytes: 89117001
+      },
+      {
+        name: "onnx/text_model_quantized.onnx",
+        url: clip("onnx/text_model_quantized.onnx"),
+        sha256: "73baab855d406190da9faa498cfedf65f15cf309f4cc7385b7b032e6d08e5c3a",
+        bytes: 64504507
+      },
+      {
+        name: "tokenizer.json",
+        url: clip("tokenizer.json"),
+        sha256: "f7f3b7af117d467b58374797691a6438d3e6b9e9cef800dfd5dced7f697a90cd",
+        bytes: 2224119
+      },
+      {
+        name: "tokenizer_config.json",
+        url: clip("tokenizer_config.json"),
+        sha256: "60ba2912bc6344c94bc16bbdec27fa1209409167b6f2fdf3cfe9e65462ea3967",
+        bytes: 775
+      }
+    ]
+  }
+];
+var DEFAULT_IMAGE_MODEL = "clip-b32";
+var imageModel = /* @__PURE__ */ __name((id2) => {
+  const found = IMAGE_MODELS.find((model) => model.id === id2);
+  if (!found) {
+    throw new CliError("validation_error", `no image model ${id2} \u2014 one of: ${IMAGE_MODELS.map((model) => model.id).join(", ")}`);
+  }
+  return found;
+}, "imageModel");
+var imageModelsDirectory = /* @__PURE__ */ __name((env = process.env) => sharedModelsDirectory("image", env), "imageModelsDirectory");
+var placedImage = /* @__PURE__ */ __name((model, directory) => model.files.map((file) => [file, join2(directory, model.id, file.name)]), "placedImage");
+var isImageModelInstalled = /* @__PURE__ */ __name((model, directory) => filesPresent(placedImage(model, directory)), "isImageModelInstalled");
+
+// 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/task.js
+var closeSuggestion = strictObject({
+  as: picklist(["done", "dismissed"]),
+  /** The agent's name. */
+  by: text,
+  /** 0–1, as the agent rated it. */
+  certainty: number(),
+  reason: nullable(text),
+  at: time
+});
+var task = strictObject({
+  ref: reference,
+  id,
+  /** The readable key: `Q-15` for a task found in a message from now on, `IN1A2B3C4D-17` before, `HRB-12` in a project. */
+  key: optional(nullable(text)),
+  title: nullable(text),
+  description: optional(nullable(text)),
+  kind: picklist(TASK_TYPES),
+  state: picklist(TASK_STATES),
+  origin: optional(picklist(TASK_ORIGINS)),
+  project: optional(nullable(text)),
+  account: optional(text),
+  /** The chat it came from, as a `chat:` reference. */
+  chat: optional(nullable(reference)),
+  /** The message it came from. */
+  source_message: optional(nullable(reference)),
+  priority: optional(nullable(number())),
+  parent: optional(nullable(reference)),
+  due_at: optional(nullable(time)),
+  closed_at: optional(nullable(time)),
+  reason: optional(nullable(text)),
+  /** One name from the category list (`tasks categories`). */
+  category: optional(nullable(text)),
+  /** Who works on it now, and until when; null when nobody does. */
+  claimed_by: optional(nullable(text)),
+  claimed_until: optional(nullable(time)),
+  /** The close an agent would make, waiting on the owner: `tasks close` confirms it, `tasks reject` refuses it. */
+  close_suggestion: optional(nullable(closeSuggestion)),
+  created_at: time,
+  updated_at: optional(time)
+});
+
+// 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/agenda.js
+var agendaChat = strictObject({
+  chat: reference,
+  title: nullable(text),
+  kind: picklist(["dialog", "group", "channel", "saved", "unknown"]),
+  /** The newest message, never its text; `null` while it is not stored. */
+  last_message: nullable(reference),
+  last_message_at: time,
+  /** `null` when the newest message is not stored, or the messenger did not say who sent it. */
+  last_from_owner: nullable(boolean()),
+  /** Open tasks whose source is in this chat. */
+  open_tasks: array(id)
+});
+var agenda = strictObject({
+  at: time,
+  account: text,
+  stored_at: nullable(time),
+  /** The store saved nothing for a day: a chat may look quiet only because nothing was synced. */
+  stale: boolean(),
+  tasks: array(strictObject({
+    id,
+    key: text,
+    title: nullable(text),
+    kind: picklist(TASK_TYPES),
+    category: nullable(text),
+    /** The message or note it came from. */
+    source: nullable(reference),
+    due_at: nullable(time),
+    next_check_at: nullable(time),
+    /** Who works on it now; only the asker's own claims are listed unless the query names claimed:. */
+    claimed_by: nullable(text),
+    claimed_until: nullable(time),
+    /** An agent's close waiting on the owner: `tasks close` confirms it, `tasks reject` refuses it. */
+    close_suggestion: nullable(closeSuggestion),
+    created_at: time,
+    reasons: array(picklist(["overdue", "due", "check", "unplanned", "close-suggested"]))
+  })),
+  /** Someone else wrote last, and the owner has not answered. */
+  owed: array(agendaChat),
+  /** The owner wrote last, and nobody answered. */
+  waiting: array(agendaChat),
+  /** The chat list says these moved and their newest message is not stored: read them first. */
+  unsynced: array(agendaChat),
+  /** Open tasks someone else does: what they owe the owner, oldest first. */
+  assigned: array(strictObject({
+    id,
+    key: text,
+    title: nullable(text),
+    kind: picklist(TASK_TYPES),
+    category: nullable(text),
+    source: nullable(reference),
+    due_at: nullable(time),
+    created_at: time,
+    /** `person:<id>`, each one who does it. */
+    assignees: array(reference)
+  })),
+  /** Open tasks carry these categories, which the list no longer holds: move them, or put the category back. */
+  unlisted_categories: array(strictObject({ name: text, open_tasks: number() }))
+});
+
+// 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/conversation.js
+var conversation = strictObject({
+  id,
+  chat: reference,
+  /** The message it starts with. */
+  first_message: reference,
+  started_at: time,
+  ended_at: time,
+  messages_count: count,
+  /** How many people wrote in it. */
+  senders_count: count,
+  built_at: time,
+  rules_version: count
+});
+
+// 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/attachment.js
+var attachment = strictObject({
+  /** The message it came with, as a locator; absent inside that message. */
+  message: optional(reference),
+  /** Lower-cased: `photo`, `video`, `file`, `voice`… */
+  kind: text,
+  /** Its place among the message's attachments, from 1, as `attachments show --attachment` takes it. */
+  position: optional(count),
+  url: optional(text),
+  name: optional(text),
+  title: optional(text),
+  mime: optional(text),
+  size: optional(count),
+  width: optional(count),
+  height: optional(count),
+  /** Seconds, for audio and video. */
+  duration: optional(number()),
+  /** The text read out of it; how it was read is `extraction`. */
+  text: optional(text),
+  extraction: optional(strictObject({ origin: text, extractor: text, chars: count, error: optional(text) })),
+  local_path: optional(text),
+  /** A bot's keyboard under the message, row by row; `messages press` presses one. */
+  buttons: optional(array(array(strictObject({
+    kind: picklist(["callback", "link", "message", "chat", "contact", "location", "app", "clipboard", "other"]),
+    text,
+    url: optional(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/tagging.js
+var tagging = strictObject({
+  tag: text,
+  type: picklist(TAG_TYPES),
+  /** What carries it: a `chat:`, `contact:` or `msg:` reference. */
+  target: reference,
+  /** The chat's title or the person's name, as the store holds it. */
+  name: nullable(text),
+  /** Who claims it: `manual` the owner, `auto` the keyword rules; both when both do. */
+  sources: array(picklist(["manual", "auto"])),
+  created_at: time
+});
+
+// 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/botcheck/reasons.js
+var WEIGHTS = {
+  bot: 3,
+  scam: 3,
+  fake: 3,
+  deleted: 1,
+  no_photo: 1,
+  no_username: 1,
+  odd_name: 1,
+  never_wrote: 1,
+  link_first: 2,
+  burst_join: 1,
+  mass_invited: 1,
+  new_account: 2,
+  no_bio: 1,
+  same_text: 2,
+  photo_recent: 1,
+  cas_banned: 3,
+  lols_banned: 3,
+  lols_scammer: 3
+};
+var LINK = /https?:\/\/|t\.me\/|www\./i;
+var DIGITS = /\d{5,}/;
+var oddName = /* @__PURE__ */ __name((name) => !name?.trim() || DIGITS.test(name) || LINK.test(name), "oddName");
+
+export {
+  logAttributes,
+  fromLogAttributes,
+  snakeLogger,
+  LOG_ATTRIBUTES,
+  KEEP_RUNS_FOR_DAYS,
+  KEEP_SUCCESSFUL_RUNS_FOR_DAYS,
+  RUNS_SIZE_LIMIT_MB,
+  runsDirFor,
+  startRun,
+  runtime,
+  newRunId,
+  listRuns,
+  findRun,
+  readEvents,
+  pruneRuns,
+  currentRun,
+  inRun,
+  runEvent,
+  typedCommand,
+  useAsProcessRun,
+  processRun,
+  enclosingTraceId,
+  traceOf,
+  childTrace,
+  withAttempt,
+  currentAttempt,
+  sentIds,
+  withWriteScope,
+  stopWrites,
+  currentOperation,
+  guardedWrite,
+  codeOf,
+  parseDuration,
+  TEXT_MODELS,
+  DEFAULT_TEXT_MODEL,
+  textModel,
+  RERANK_MODELS,
+  DEFAULT_RERANK_MODEL,
+  rerankModel,
+  vectorModelKey,
+  meaningFloor,
+  IMAGE_MODELS,
+  DEFAULT_IMAGE_MODEL,
+  imageModel,
+  imageModelsDirectory,
+  placedImage,
+  isImageModelInstalled,
+  WEIGHTS,
+  LINK,
+  oddName,
+  closeSuggestion,
+  task,
+  agenda,
+  conversation,
+  attachment,
+  tagging
+};