pushary 1.8.0

package/dist/chunk-SLFABHW3.js

@@ -0,0 +1,150 @@
+import {
+  parseSseMessages
+} from "./chunk-M5ICYGHT.js";
+import {
+  NPX_LATEST_COMMAND
+} from "./chunk-E4FJTUH4.js";
+
+// src/mcp-stdio-bridge.ts
+var MCP_BRIDGE_BINARY = "pushary-mcp";
+var MCP_BRIDGE_PATH = "/api/mcp/mcp";
+var MCP_BRIDGE_REQUEST_TIMEOUT_MS = 9e4;
+var JSON_RPC_PARSE_ERROR = -32700;
+var MCP_BRIDGE_ERROR = -32e3;
+var MCP_MAX_RESPONSE_BYTES = 1024 * 1024;
+var MCP_SESSION_HEADER = "mcp-session-id";
+var MCP_PROTOCOL_HEADER = "mcp-protocol-version";
+var INITIALIZE_METHOD = "initialize";
+var MISSING_KEY_MESSAGE = `Pushary has no API key for this machine. Run \`${NPX_LATEST_COMMAND} setup\`.`;
+var REJECTED_KEY_MESSAGE = `Pushary rejected this machine's API key. Run \`${NPX_LATEST_COMMAND} setup\` to sign in again.`;
+var PARSE_ERROR_MESSAGE = "Parse error";
+var NO_RESPONSE_MESSAGE = "Pushary sent no response.";
+var unreachableMessage = (err) => `Pushary is unreachable: ${err instanceof Error ? err.message : String(err)}`;
+var asRecord = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+var isJsonRpcId = (value) => typeof value === "string" || typeof value === "number";
+var messagesOf = (payload) => Array.isArray(payload) ? payload : [payload];
+var requestOf = (message) => {
+  const record = asRecord(message);
+  return record && typeof record.method === "string" && isJsonRpcId(record.id) ? [{ id: record.id, method: record.method }] : [];
+};
+var requestsIn = (payload) => messagesOf(payload).flatMap(requestOf);
+var isJsonRpcMessage = (message) => asRecord(message)?.jsonrpc === "2.0";
+var responseIdOf = (message) => {
+  const record = asRecord(message);
+  return record && !("method" in record) && isJsonRpcId(record.id) ? record.id : void 0;
+};
+var bridgeError = (id, message, code = MCP_BRIDGE_ERROR) => ({
+  jsonrpc: "2.0",
+  id,
+  error: { code, message }
+});
+var parseBridgeLine = (line) => {
+  try {
+    return { ok: true, payload: JSON.parse(line) };
+  } catch {
+    return { ok: false };
+  }
+};
+var parseMcpMessages = (body, contentType) => {
+  if (!body.trim()) return [];
+  if (contentType?.includes("text/event-stream")) return parseSseMessages(body);
+  const parsed = parseBridgeLine(body);
+  return parsed.ok ? messagesOf(parsed.payload) : [];
+};
+var httpFailureMessage = (status, hasKey, body) => {
+  if (status === 401) return hasKey ? REJECTED_KEY_MESSAGE : MISSING_KEY_MESSAGE;
+  const detail = body.trim().slice(0, 300);
+  return detail ? `Pushary returned ${status}: ${detail}` : `Pushary returned ${status}.`;
+};
+var negotiatedProtocolOf = (messages, initializeIds) => {
+  for (const message of messages) {
+    const id = responseIdOf(message);
+    const version = asRecord(asRecord(message)?.result)?.protocolVersion;
+    if (id !== void 0 && initializeIds.has(id) && typeof version === "string") return version;
+  }
+  return void 0;
+};
+var readBoundedResponse = async (response) => {
+  if (!response.body) return "";
+  const reader = response.body.getReader();
+  const chunks = [];
+  let size = 0;
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      size += value.byteLength;
+      if (size > MCP_MAX_RESPONSE_BYTES) throw new Error("MCP response exceeds the 1 MiB limit.");
+      chunks.push(value);
+    }
+    return Buffer.concat(chunks).toString("utf8");
+  } finally {
+    await reader.cancel().catch(() => void 0);
+    reader.releaseLock();
+  }
+};
+var createMcpStdioBridge = (deps) => {
+  let sessionId = null;
+  let protocolVersion = null;
+  const headersFor = (apiKey) => ({
+    "Content-Type": "application/json",
+    "Accept": "application/json, text/event-stream",
+    ...apiKey ? { Authorization: `Bearer ${apiKey}` } : {},
+    ...sessionId ? { [MCP_SESSION_HEADER]: sessionId } : {},
+    ...protocolVersion ? { [MCP_PROTOCOL_HEADER]: protocolVersion } : {}
+  });
+  const failRequests = async (requests, message, answered = /* @__PURE__ */ new Set()) => {
+    for (const request of requests) {
+      if (!answered.has(request.id)) await deps.emit(bridgeError(request.id, message));
+    }
+  };
+  const post = async (line, apiKey) => deps.fetchImpl(deps.endpoint, {
+    method: "POST",
+    headers: headersFor(apiKey),
+    body: line,
+    signal: AbortSignal.timeout(deps.timeoutMs ?? MCP_BRIDGE_REQUEST_TIMEOUT_MS)
+  });
+  const forward = async (line) => {
+    const parsed = parseBridgeLine(line);
+    if (!parsed.ok) {
+      await deps.emit(bridgeError(null, PARSE_ERROR_MESSAGE, JSON_RPC_PARSE_ERROR));
+      return;
+    }
+    const requests = requestsIn(parsed.payload);
+    const apiKey = deps.apiKey();
+    let response;
+    let body;
+    try {
+      response = await post(line, apiKey);
+      body = await readBoundedResponse(response);
+    } catch (err) {
+      await failRequests(requests, unreachableMessage(err));
+      return;
+    }
+    sessionId = response.headers.get(MCP_SESSION_HEADER) ?? sessionId;
+    const messages = parseMcpMessages(body, response.headers.get("content-type")).filter(isJsonRpcMessage);
+    const initializeIds = new Set(requests.filter((request) => request.method === INITIALIZE_METHOD).map((request) => request.id));
+    protocolVersion = negotiatedProtocolOf(messages, initializeIds) ?? protocolVersion;
+    for (const message of messages) await deps.emit(message);
+    const answered = new Set(messages.map(responseIdOf).filter(isJsonRpcId));
+    const failure = response.ok ? NO_RESPONSE_MESSAGE : httpFailureMessage(response.status, apiKey !== null, body);
+    await failRequests(requests, failure, answered);
+  };
+  const reject = async (line, message) => {
+    const parsed = parseBridgeLine(line);
+    if (!parsed.ok) {
+      await deps.emit(bridgeError(null, PARSE_ERROR_MESSAGE, JSON_RPC_PARSE_ERROR));
+      return;
+    }
+    await failRequests(requestsIn(parsed.payload), message);
+  };
+  return { forward, reject };
+};
+
+export {
+  MCP_BRIDGE_BINARY,
+  MCP_BRIDGE_PATH,
+  bridgeError,
+  parseBridgeLine,
+  createMcpStdioBridge
+};

package/dist/chunk-T7E75EKA.js

@@ -0,0 +1,67 @@
+// src/cli/fsx.ts
+import { copyFileSync, lstatSync, realpathSync, existsSync, fsyncSync, mkdirSync, openSync, closeSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+var readJsonSafe = (filePath) => {
+  let raw;
+  try {
+    raw = readFileSync(filePath, "utf-8");
+  } catch (err) {
+    const error = err;
+    if (error.code === "ENOENT") return { kind: "missing" };
+    return { kind: "unreadable", error };
+  }
+  if (raw.trim() === "") return { kind: "ok", value: {} };
+  try {
+    return { kind: "ok", value: JSON.parse(raw) };
+  } catch (err) {
+    return { kind: "unparseable", error: err, raw };
+  }
+};
+var stamp = () => (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+var backupFile = (filePath) => {
+  const target = `${filePath}.pushary-backup-${stamp()}`;
+  copyFileSync(filePath, target);
+  return target;
+};
+var writeFileAtomic = (filePath, contents, mode, encoding = "utf-8") => {
+  const target = lstatSync(filePath, { throwIfNoEntry: false })?.isSymbolicLink() ? realpathSync(filePath) : filePath;
+  const dir = dirname(target);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  const temp = join(dir, `.${process.pid}-${stamp()}.pushary-tmp`);
+  try {
+    writeFileSync(temp, contents, mode === void 0 ? encoding : { encoding, mode });
+    const handle = openSync(temp, "r+");
+    try {
+      fsyncSync(handle);
+    } finally {
+      closeSync(handle);
+    }
+    renameSync(temp, target);
+  } catch (err) {
+    try {
+      if (existsSync(temp)) unlinkSync(temp);
+    } catch {
+    }
+    throw err;
+  }
+};
+var writeJsonAtomic = (filePath, data, mode) => writeFileAtomic(filePath, `${JSON.stringify(data, null, 2)}
+`, mode);
+var writeJsonAtomicDurable = (filePath, data, mode) => {
+  writeJsonAtomic(filePath, data, mode);
+  if (process.platform === "win32") return;
+  const directory = openSync(dirname(filePath), "r");
+  try {
+    fsyncSync(directory);
+  } finally {
+    closeSync(directory);
+  }
+};
+
+export {
+  readJsonSafe,
+  backupFile,
+  writeFileAtomic,
+  writeJsonAtomic,
+  writeJsonAtomicDurable
+};

package/dist/chunk-TY4JT7W3.js

@@ -0,0 +1,38 @@
+import {
+  NPX_LATEST_COMMAND
+} from "./chunk-E4FJTUH4.js";
+
+// src/setup/codex-trust.ts
+var CODEX_TRUST_TELEMETRY = {
+  verified: "verified",
+  refused: "manual",
+  unlisted: "manual",
+  skipped: "unverified",
+  unavailable: "unverified"
+};
+var isUnanswered = (confirmation) => confirmation.kind === "skipped" || confirmation.kind === "unavailable";
+var codexTrustOutcome = (confirmation, portedTrustWritten) => isUnanswered(confirmation) && !portedTrustWritten ? "manual" : CODEX_TRUST_TELEMETRY[confirmation.kind];
+var CODEX_TRUST_REFUSED = "Codex did not accept the trust Pushary asked for, so its hooks are not trusted yet. Open Codex, run /hooks, and choose Trust for the Pushary hooks.";
+var describeUnlistedCodexHooks = (warnings) => {
+  const said = warnings[0] ? ` Codex said: ${warnings[0]}` : "";
+  return `Codex does not list the Pushary hooks, so it will not run them.${said} Run ${NPX_LATEST_COMMAND} doctor for details.`;
+};
+var describeCodexTrustConfirmation = (confirmation) => {
+  switch (confirmation.kind) {
+    case "verified":
+      return confirmation.wrote ? "Codex trusted the Pushary hooks when asked, and confirmed it." : "Codex confirms the Pushary hooks are trusted.";
+    case "refused":
+      return confirmation.writeError ? `${CODEX_TRUST_REFUSED} Codex said: ${confirmation.writeError}` : CODEX_TRUST_REFUSED;
+    case "unlisted":
+      return describeUnlistedCodexHooks(confirmation.warnings);
+    case "skipped":
+      return `Pushary did not ask Codex to confirm the trust: ${confirmation.reason}.`;
+    case "unavailable":
+      return `Codex could not be asked to confirm the Pushary hooks are trusted (${confirmation.reason}).`;
+  }
+};
+
+export {
+  codexTrustOutcome,
+  describeCodexTrustConfirmation
+};

package/dist/chunk-U4TMAANR.js

@@ -0,0 +1,111 @@
+// src/cli/terminal-row.ts
+var visibleLength = (text) => text.replace(/\x1b\[[0-9;]*m/g, "").length;
+var clipToRow = (text, columns) => {
+  const budget = columns - 4;
+  if (budget <= 1 || visibleLength(text) <= budget) return text;
+  let visible = 0;
+  let out = "";
+  for (let i = 0; i < text.length; i += 1) {
+    const escape = /^\x1b\[[0-9;]*m/.exec(text.slice(i));
+    if (escape) {
+      out += escape[0];
+      i += escape[0].length - 1;
+      continue;
+    }
+    if (visible >= budget - 1) break;
+    out += text[i];
+    visible += 1;
+  }
+  return `${out}\u2026`;
+};
+var terminalColumns = (stream = process.stdout) => {
+  const columns = stream.columns;
+  return typeof columns === "number" && columns > 0 ? columns : 80;
+};
+
+// src/cli/io.ts
+var truthyLevel = (value) => {
+  if (value === void 0) return void 0;
+  if (value === "" || value === "false") return 0;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : 1;
+};
+var ANSI_RESET = "\x1B[0m";
+var ansiPainter = (enabled) => (open) => (text) => enabled() ? `${open}${text}${ANSI_RESET}` : text;
+var useColor = (context = {}, stream = process.stdout) => {
+  const forced = truthyLevel(process.env.FORCE_COLOR);
+  if (forced !== void 0) return forced > 0;
+  if (context.color === false) return false;
+  if (process.env.NO_COLOR !== void 0 && process.env.NO_COLOR !== "") return false;
+  if (process.env.TERM === "dumb") return false;
+  if (context.json) return false;
+  return stream.isTTY === true;
+};
+var SPINNER_FRAMES = ["   ", ".  ", ".. ", "..."];
+var SPINNER_FRAME_WIDTH = SPINNER_FRAMES[0].length + 1;
+var SPINNER_INTERVAL_MS = 200;
+var describeError = (err) => {
+  if (err instanceof Error) {
+    const signalled = err;
+    if (signalled.killed && signalled.signal === "SIGTERM") {
+      return "timed out, check your network connection";
+    }
+    return err.message;
+  }
+  return String(err);
+};
+var createIo = (stream = process.stdout, context = {}) => {
+  const color = useColor(context, stream);
+  const wrap = (open) => (s) => color ? `${open}${s}\x1B[0m` : s;
+  const bold = wrap("\x1B[1m");
+  const dim = wrap("\x1B[2m");
+  const green = wrap("\x1B[32m");
+  const yellow = wrap("\x1B[33m");
+  const red = wrap("\x1B[31m");
+  const cyan = wrap("\x1B[36m");
+  const check = () => green("\u2713");
+  const line = (s = "") => {
+    stream.write(`${s}
+`);
+  };
+  const warn = (s) => {
+    process.stderr.write(`${yellow("!")} ${s}
+`);
+  };
+  const spinner = async (label, fn, options = {}) => {
+    if (stream.isTTY !== true) {
+      try {
+        await fn();
+        line(`  ${check()} ${label}`);
+      } catch (err) {
+        line(`  ${yellow("!")} ${label} ${dim(`(${describeError(err)})`)}`);
+        if (!options.optional) throw err;
+      }
+      return;
+    }
+    let frame = 0;
+    const timer = setInterval(() => {
+      stream.write(`\r  ${dim(SPINNER_FRAMES[frame++ % SPINNER_FRAMES.length])} ${clipToRow(label, terminalColumns(stream) - SPINNER_FRAME_WIDTH)}\x1B[K`);
+    }, SPINNER_INTERVAL_MS);
+    try {
+      await fn();
+      clearInterval(timer);
+      stream.write(`\r  ${check()} ${label}\x1B[K
+`);
+    } catch (err) {
+      clearInterval(timer);
+      stream.write(`\r  ${yellow("!")} ${label} ${dim(`(${describeError(err)})`)}\x1B[K
+`);
+      if (!options.optional) throw err;
+    }
+  };
+  return { color, bold, dim, green, yellow, red, cyan, check, line, warn, spinner };
+};
+
+export {
+  clipToRow,
+  terminalColumns,
+  ansiPainter,
+  useColor,
+  createIo
+};

package/dist/chunk-UI36QSBI.js

@@ -0,0 +1,177 @@
+import {
+  isDisabledByEnv
+} from "./chunk-POFBE6ZY.js";
+import {
+  autoUpdateState
+} from "./chunk-A2A2YTMG.js";
+import {
+  readJsonSafe,
+  writeJsonAtomic
+} from "./chunk-T7E75EKA.js";
+import {
+  CLI_PACKAGE_NAMES,
+  POSIX_GLOBAL_ROOT_SEGMENTS,
+  cliPackagePathSegments,
+  globalUpgradeEntry,
+  ownPackageRoot
+} from "./chunk-NQTHFF4W.js";
+
+// src/auto-update.ts
+import { spawn } from "child_process";
+import { dirname } from "path";
+var AUTO_UPDATE_DISABLE_ENV = "PUSHARY_DISABLE_AUTOUPDATE";
+var AUTO_UPDATE_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+var AUTO_UPDATE_FLAG = "--auto";
+var NON_GLOBAL_INSTALL_SEGMENTS = ["/_npx/", "/.volta/"];
+var AUTO_UPDATE_RESULTS = ["updated", "current", "needs_manual", "failed", "finish_pending"];
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isAutoUpdateResult = (value) => typeof value === "string" && AUTO_UPDATE_RESULTS.some((result) => result === value);
+var stringField = (record, key) => {
+  const value = record[key];
+  return typeof value === "string" ? value : void 0;
+};
+var booleanField = (record, key) => {
+  const value = record[key];
+  return typeof value === "boolean" ? value : void 0;
+};
+var parseAutoUpdateState = (value) => {
+  if (!isRecord(value)) return {};
+  return {
+    disabled: booleanField(value, "disabled"),
+    lastCheckAt: stringField(value, "lastCheckAt"),
+    lastResult: isAutoUpdateResult(value.lastResult) ? value.lastResult : void 0,
+    from: stringField(value, "from"),
+    to: stringField(value, "to"),
+    at: stringField(value, "at"),
+    detail: stringField(value, "detail"),
+    announced: booleanField(value, "announced")
+  };
+};
+var isAutoUpdateDisabledByEnv = (env) => isDisabledByEnv(env, AUTO_UPDATE_DISABLE_ENV);
+var isContinuousIntegration = (env) => Boolean(env.CI);
+var autoUpdateOffReason = (input) => {
+  if (isAutoUpdateDisabledByEnv(input.env)) return "disabled_by_env";
+  if (input.state.disabled === true) return "disabled_by_user";
+  if (isContinuousIntegration(input.env)) return "ci";
+  if (input.platform === "win32") return "windows";
+  if (input.platform === "linux") return "linux";
+  return null;
+};
+var globalPackageSubpath = (name) => `/${[...POSIX_GLOBAL_ROOT_SEGMENTS, ...cliPackagePathSegments(name)].join("/")}`;
+var prefixOfGlobalPackage = (root, name) => {
+  const subpath = globalPackageSubpath(name);
+  if (!root.endsWith(subpath)) return null;
+  const prefix = root.slice(0, -subpath.length);
+  return prefix.startsWith("/") ? prefix : null;
+};
+var isNonGlobalInstall = (root) => NON_GLOBAL_INSTALL_SEGMENTS.some((segment) => root.includes(segment));
+var globalInstallLocation = (packageRoot) => {
+  const root = packageRoot.replace(/\/+$/, "");
+  if (isNonGlobalInstall(root)) return null;
+  for (const packageName of CLI_PACKAGE_NAMES) {
+    const prefix = prefixOfGlobalPackage(root, packageName);
+    if (prefix !== null) return { prefix, packageName };
+  }
+  return null;
+};
+var upgradeEntryFor = (location, platform = process.platform) => globalUpgradeEntry(location.prefix, location.packageName, platform);
+var checkedWithinInterval = (lastCheckAt, now) => {
+  const last = lastCheckAt === void 0 ? Number.NaN : Date.parse(lastCheckAt);
+  if (Number.isNaN(last)) return false;
+  const elapsed = now - last;
+  return elapsed >= 0 && elapsed < AUTO_UPDATE_INTERVAL_MS;
+};
+var autoUpdateDecision = (input) => {
+  if (input.isSubagentStart) return { kind: "skip", reason: "subagent_start" };
+  const offReason = autoUpdateOffReason(input);
+  if (offReason !== null) return { kind: "skip", reason: offReason };
+  const location = input.packageRoot === void 0 ? null : globalInstallLocation(input.packageRoot);
+  if (location === null) return { kind: "skip", reason: "not_global_install" };
+  if (checkedWithinInterval(input.state.lastCheckAt, input.now)) return { kind: "skip", reason: "checked_recently" };
+  return { kind: "check", ...location };
+};
+var parseAutoUpdateFlag = (args) => {
+  const token = args.find((arg) => arg === AUTO_UPDATE_FLAG || arg.startsWith(`${AUTO_UPDATE_FLAG}=`));
+  if (token === void 0) return { kind: "absent" };
+  if (token === AUTO_UPDATE_FLAG) return { kind: "run" };
+  const value = token.slice(AUTO_UPDATE_FLAG.length + 1);
+  if (value === "on") return { kind: "set", enabled: true };
+  if (value === "off") return { kind: "set", enabled: false };
+  return { kind: "invalid", value };
+};
+var AUTO_UPDATE_RESULT_LABELS = {
+  updated: "updated",
+  finish_pending: "installed; configuration refresh pending",
+  current: "up to date",
+  needs_manual: "needs a manual upgrade",
+  failed: "failed"
+};
+var versionsOf = (state) => state.from && state.to ? `${state.from} to ${state.to}` : state.from;
+var describeAutoUpdateCheck = (state) => {
+  const label = state.lastResult ? AUTO_UPDATE_RESULT_LABELS[state.lastResult] : "no result recorded";
+  return [label, versionsOf(state), state.detail].filter(Boolean).join(", ");
+};
+var hasPendingUpgradeFinish = (state, installed) => state.to === installed && (state.lastResult === "finish_pending" || state.lastResult === "updated" && Boolean(state.detail));
+var pendingAutoUpdateAnnouncement = (state) => state.lastResult === "updated" && state.announced !== true && state.from && state.to ? { from: state.from, to: state.to } : null;
+var describeAutoUpdateAnnouncement = (announcement) => `Pushary updated itself from ${announcement.from} to ${announcement.to}.`;
+var takeAutoUpdateAnnouncement = (statePath, markAnnounced) => {
+  try {
+    const announcement = pendingAutoUpdateAnnouncement(readAutoUpdateState(statePath));
+    if (announcement && markAnnounced) updateAutoUpdateState(statePath, { announced: true });
+    return announcement;
+  } catch {
+    return null;
+  }
+};
+var readAutoUpdateState = (statePath) => {
+  const read = readJsonSafe(statePath);
+  return read.kind === "ok" ? parseAutoUpdateState(read.value) : {};
+};
+var updateAutoUpdateState = (statePath, patch) => {
+  const next = { ...readAutoUpdateState(statePath), ...patch };
+  writeJsonAtomic(statePath, next);
+  return next;
+};
+var ignoreSpawnFailure = () => void 0;
+var spawnDetached = (command, args, cwd) => {
+  const child = spawn(command, [...args], { cwd, detached: true, stdio: "ignore" });
+  child.on("error", ignoreSpawnFailure);
+  child.unref();
+};
+var triggerAutoUpdate = (trigger) => {
+  try {
+    const statePath = trigger.statePath ?? autoUpdateState();
+    const now = trigger.now ?? Date.now();
+    const decision = autoUpdateDecision({
+      env: trigger.env ?? process.env,
+      state: readAutoUpdateState(statePath),
+      now,
+      platform: trigger.platform ?? process.platform,
+      packageRoot: trigger.packageRoot ?? ownPackageRoot(),
+      isSubagentStart: trigger.isSubagentStart
+    });
+    if (decision.kind === "skip") return decision;
+    updateAutoUpdateState(statePath, { lastCheckAt: new Date(now).toISOString() });
+    const spawnUpgrade = trigger.spawn ?? spawnDetached;
+    spawnUpgrade(trigger.execPath ?? process.execPath, [upgradeEntryFor(decision), AUTO_UPDATE_FLAG], dirname(statePath));
+    return decision;
+  } catch {
+    return null;
+  }
+};
+
+export {
+  AUTO_UPDATE_DISABLE_ENV,
+  isAutoUpdateDisabledByEnv,
+  autoUpdateOffReason,
+  globalInstallLocation,
+  upgradeEntryFor,
+  parseAutoUpdateFlag,
+  describeAutoUpdateCheck,
+  hasPendingUpgradeFinish,
+  describeAutoUpdateAnnouncement,
+  takeAutoUpdateAnnouncement,
+  readAutoUpdateState,
+  updateAutoUpdateState,
+  triggerAutoUpdate
+};