@wirecat/bitrix24-cli 0.3.0 → 0.5.0

package/dist/bundle/chunk-G5MW6RCM.js

@@ -0,0 +1,723 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  CliError,
+  createRecordLog,
+  isCliError,
+  resolvePaths,
+  traceIdOf,
+  writeSecurely
+} from "./chunk-EYYOKT23.js";
+import {
+  __name
+} from "./chunk-ZVVMGPBJ.js";
+
+// node_modules/.pnpm/@wirecat+cli-core@0.601.0_@wirecat+cli-base@0.80.9_commander@15.0.0_esbuild@0.28.2_type_4fddd50439ae4e4f952967ea26554e7b/node_modules/@wirecat/cli-core/dist/ports/app.js
+var envName = /* @__PURE__ */ __name((app, name) => `${app.envPrefix}_${name}`, "envName");
+var readOnlyLockOf = /* @__PURE__ */ __name((app, env) => {
+  const name = envName(app, "READ_ONLY");
+  const value = env[name];
+  return value === void 0 || value.trim() === "" || value === "0" ? void 0 : name;
+}, "readOnlyLockOf");
+var mailHolderVariable = /* @__PURE__ */ __name((app) => envName(app, "MAIL_HOLDER"), "mailHolderVariable");
+var MESSENGER_CHANGE_REFUSAL = "send, react, change chats or change the account";
+var readOnlyRefusal = /* @__PURE__ */ __name((lock, what) => new CliError("permission_error", `this process is read-only (${lock}) \u2014 it cannot ${what}`), "readOnlyRefusal");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.601.0_@wirecat+cli-base@0.80.9_commander@15.0.0_esbuild@0.28.2_type_4fddd50439ae4e4f952967ea26554e7b/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.601.0_@wirecat+cli-base@0.80.9_commander@15.0.0_esbuild@0.28.2_type_4fddd50439ae4e4f952967ea26554e7b/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.601.0_@wirecat+cli-base@0.80.9_commander@15.0.0_esbuild@0.28.2_type_4fddd50439ae4e4f952967ea26554e7b/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";
+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 id = options.runId ?? newRunId(startedAt, options.command);
+  const dir = join(options.runsDir, day(startedAt), id);
+  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: id,
+    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: id,
+      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,
+    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, id) => {
+  const stamped = /^(\d{4})(\d{2})(\d{2})T/.exec(id);
+  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, id);
+    const metadata = readRun(dir);
+    if (metadata)
+      return { dir, metadata };
+  }
+  for (const date of dates) {
+    const metadata = indexedRuns(join(runsDir, date)).get(id);
+    if (metadata)
+      return { dir: join(runsDir, date, id), 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, severity } = line;
+  if (attributes === null || typeof attributes !== "object")
+    return logAttributes(line);
+  return { time, 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 [id, metadata] of indexedRuns(dayDir)) {
+      if (metadata.status === "success")
+        rmSync(join(dayDir, id), { 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.601.0_@wirecat+cli-base@0.80.9_commander@15.0.0_esbuild@0.28.2_type_4fddd50439ae4e4f952967ea26554e7b/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.601.0_@wirecat+cli-base@0.80.9_commander@15.0.0_esbuild@0.28.2_type_4fddd50439ae4e4f952967ea26554e7b/node_modules/@wirecat/cli-core/dist/background/budget.js
+var DEADLINE_MARGIN_MS = 5e3;
+var DEADLINE_MARGIN_SHARE = 0.15;
+var DEFAULT_REQUEST_MS = 2e3;
+var deadlineMargin = /* @__PURE__ */ __name((deadline) => Math.max(DEADLINE_MARGIN_MS, deadline.ms * DEADLINE_MARGIN_SHARE), "deadlineMargin");
+var requestsFor = /* @__PURE__ */ __name((deadline, requestMs = DEFAULT_REQUEST_MS) => deadline === void 0 ? null : Math.max(1, Math.floor((deadline.ms - deadlineMargin(deadline)) / requestMs)), "requestsFor");
+var runBudget = /* @__PURE__ */ __name(({ requests, deadline, requestMs, signal, now = Date.now } = {}) => {
+  const fits = requestsFor(deadline, requestMs);
+  const limit = fits === null ? requests ?? null : Math.min(fits, requests ?? fits);
+  const margin = deadline ? deadlineMargin(deadline) : 0;
+  let used = 0;
+  let stopped2 = null;
+  let last;
+  let slowest = 0;
+  return {
+    take() {
+      if (stopped2)
+        return stopped2;
+      const at = now();
+      if (last !== void 0)
+        slowest = Math.max(slowest, at - last);
+      if (signal?.aborted)
+        stopped2 = "cancelled";
+      else if (limit !== null && used >= limit)
+        stopped2 = "requests";
+      else if (deadline && at + margin + slowest >= deadline.endsAt)
+        stopped2 = "deadline";
+      if (stopped2)
+        return stopped2;
+      used += 1;
+      last = at;
+      return null;
+    },
+    get used() {
+      return used;
+    },
+    limit,
+    get stopped() {
+      return stopped2;
+    }
+  };
+}, "runBudget");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.601.0_@wirecat+cli-base@0.80.9_commander@15.0.0_esbuild@0.28.2_type_4fddd50439ae4e4f952967ea26554e7b/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.601.0_@wirecat+cli-base@0.80.9_commander@15.0.0_esbuild@0.28.2_type_4fddd50439ae4e4f952967ea26554e7b/node_modules/@wirecat/cli-core/dist/background/checkpoints.js
+var progressOf = /* @__PURE__ */ __name((input) => {
+  const total = input.total ?? null;
+  const updated = input.updatedAt ?? null;
+  return {
+    job: input.job,
+    profile: input.profile,
+    done: input.done,
+    total,
+    remaining: total === null ? null : Math.max(0, total - input.done),
+    state: input.complete ?? (total !== null && input.done >= total) ? "complete" : "partial",
+    updated_at: updated,
+    cursor_age_ms: updated === null ? null : Math.max(0, (input.now ?? /* @__PURE__ */ new Date()).getTime() - Date.parse(updated))
+  };
+}, "progressOf");
+var ago = /* @__PURE__ */ __name((ms) => {
+  const minutes = Math.round(ms / 6e4);
+  if (minutes < 1)
+    return "just now";
+  if (minutes < 60)
+    return `${minutes}m ago`;
+  const hours = Math.round(minutes / 60);
+  return hours < 48 ? `${hours}h ago` : `${Math.round(hours / 24)}d ago`;
+}, "ago");
+var progressLine = /* @__PURE__ */ __name((progress) => {
+  const count = /* @__PURE__ */ __name((n) => n.toLocaleString("en-US"), "count");
+  const of = progress.total === null ? count(progress.done) : `${count(progress.done)} of ${count(progress.total)} (${progress.total === 0 ? 100 : Math.floor(progress.done / progress.total * 100)}%), ${count(progress.remaining ?? 0)} left`;
+  const when = progress.cursor_age_ms === null ? "" : `, updated ${ago(progress.cursor_age_ms)}`;
+  return `${progress.job} ${progress.profile}: ${of} \u2014 ${progress.state}${when}`;
+}, "progressLine");
+
+export {
+  progressOf,
+  progressLine,
+  envName,
+  readOnlyLockOf,
+  mailHolderVariable,
+  MESSENGER_CHANGE_REFUSAL,
+  readOnlyRefusal,
+  logAttributes,
+  fromLogAttributes,
+  snakeLogger,
+  LOG_ATTRIBUTES,
+  KEEP_SUCCESSFUL_RUNS_FOR_DAYS,
+  RUNS_SIZE_LIMIT_MB,
+  runsDirFor,
+  startRun,
+  runtime,
+  newRunId,
+  listRuns,
+  findRun,
+  readEvents,
+  currentRun,
+  inRun,
+  runEvent,
+  typedCommand,
+  useAsProcessRun,
+  processRun,
+  enclosingTraceId,
+  traceOf,
+  childTrace,
+  withAttempt,
+  currentAttempt,
+  runBudget,
+  sentIds,
+  withWriteScope,
+  stopWrites,
+  currentOperation,
+  guardedWrite,
+  codeOf
+};