@herbertgao/pi-extensions 2026.8.14 → 2026.9.0

package/node_modules/@narumitw/pi-caffeinate/dist/index.ts

@@ -0,0 +1,1112 @@
+// @generated by scripts/build-runtime.mjs; do not edit.
+// @ts-nocheck -- generated JavaScript uses a .ts extension for Pi's Jiti loader.
+
+// src/caffeinate.ts
+import process4 from "node:process";
+
+// src/dbus-inhibit.ts
+var SCREENSAVER_BUS_NAME = "org.freedesktop.ScreenSaver";
+var SCREENSAVER_INTERFACE = "org.freedesktop.ScreenSaver";
+var INHIBIT_REASON = "Pi agent is running";
+var INHIBIT_APPLICATION_NAME = "pi-caffeinate";
+var SCREENSAVER_OBJECT_PATHS = ["/org/freedesktop/ScreenSaver", "/ScreenSaver"];
+var DBUS_CALL_TIMEOUT_MS = 2e3;
+async function defaultDbusScreenSaverFactory() {
+  const { sessionBus } = await import("dbus-native");
+  return new NativeScreenSaverClient(sessionBus());
+}
+var NativeScreenSaverClient = class {
+  constructor(bus) {
+    this.bus = bus;
+    this.bus.connection.on("error", this.handleConnectionError);
+    this.bus.connection.on("close", this.handleConnectionClose);
+  }
+  bus;
+  cookie;
+  objectPath;
+  failureHandler;
+  pendingFailure;
+  lastConnectionError;
+  closing = false;
+  handleConnectionError = (error) => {
+    this.lastConnectionError = toError(error, "D-Bus session connection failed");
+    if (this.cookie !== void 0) this.reportFailure(this.lastConnectionError);
+  };
+  handleConnectionClose = (error) => {
+    if (this.closing || this.cookie === void 0) return;
+    this.reportFailure(
+      toError(error, this.lastConnectionError?.message ?? "D-Bus session connection closed")
+    );
+  };
+  setFailureHandler(handler) {
+    this.failureHandler = handler;
+    if (!handler || !this.pendingFailure) return;
+    const failure = this.pendingFailure;
+    this.pendingFailure = void 0;
+    handler(failure);
+  }
+  async inhibit(reason, signal) {
+    let lastError;
+    for (const objectPath of SCREENSAVER_OBJECT_PATHS) {
+      if (signal?.aborted) throw abortReason(signal);
+      try {
+        this.cookie = await invoke(
+          this.bus,
+          {
+            destination: SCREENSAVER_BUS_NAME,
+            path: objectPath,
+            interface: SCREENSAVER_INTERFACE,
+            member: "Inhibit",
+            signature: "ss",
+            body: [INHIBIT_APPLICATION_NAME, reason]
+          },
+          signal
+        );
+        this.objectPath = objectPath;
+        return;
+      } catch (error) {
+        if (signal?.aborted) throw abortReason(signal);
+        lastError = error;
+      }
+    }
+    throw new Error(`D-Bus idle inhibit failed: ${formatError(lastError)}`, {
+      cause: lastError
+    });
+  }
+  async uninhibit() {
+    if (this.cookie === void 0 || !this.objectPath) return;
+    const cookie = this.cookie;
+    this.cookie = void 0;
+    const objectPath = this.objectPath;
+    this.objectPath = void 0;
+    await invoke(this.bus, {
+      destination: SCREENSAVER_BUS_NAME,
+      path: objectPath,
+      interface: SCREENSAVER_INTERFACE,
+      member: "UnInhibit",
+      signature: "u",
+      body: [cookie]
+    });
+  }
+  async close() {
+    this.closing = true;
+    this.cookie = void 0;
+    this.objectPath = void 0;
+    this.failureHandler = void 0;
+    try {
+      await this.bus.close();
+    } finally {
+      this.bus.connection.off("error", this.handleConnectionError);
+      this.bus.connection.off("close", this.handleConnectionClose);
+    }
+  }
+  reportFailure(error) {
+    if (this.cookie === void 0) return;
+    this.cookie = void 0;
+    this.objectPath = void 0;
+    if (this.failureHandler) this.failureHandler(error);
+    else this.pendingFailure = error;
+  }
+};
+function invoke(bus, message, signal) {
+  return new Promise((resolve, reject) => {
+    bus.invoke(message, { signal, timeout: DBUS_CALL_TIMEOUT_MS }, (error, ...values) => {
+      if (error) reject(error);
+      else resolve(values[0]);
+    });
+  });
+}
+function abortReason(signal) {
+  return signal.reason ?? new DOMException("D-Bus idle inhibit cancelled", "AbortError");
+}
+function toError(error, fallback) {
+  return error instanceof Error ? error : new Error(fallback);
+}
+function formatError(error) {
+  if (error instanceof Error) {
+    return error.name === "Error" ? error.message : `${error.name}: ${error.message}`;
+  }
+  return String(error);
+}
+
+// src/inhibitor-process.ts
+import { spawn } from "node:child_process";
+import process from "node:process";
+function startInhibitorProcess(command, onError, onUnexpectedExit) {
+  const child = spawn(command.command, command.args, {
+    detached: false,
+    stdio: [command.releaseOnStdinClose ? "pipe" : "ignore", "pipe", "pipe"]
+  });
+  child.once("error", onError);
+  child.once("exit", (code, signal) => onUnexpectedExit(formatExit(code, signal)));
+  return child;
+}
+function stopInhibitorProcess(child, command) {
+  child.removeAllListeners("exit");
+  child.removeAllListeners("error");
+  if (child.killed) return;
+  if (command?.releaseOnStdinClose && child.stdin && !child.stdin.destroyed) {
+    child.stdin.end();
+    if (child.exitCode === null && child.signalCode === null) {
+      const killTimer = setTimeout(() => {
+        if (child.exitCode === null && child.signalCode === null && !child.killed) child.kill();
+      }, 2e3);
+      killTimer.unref();
+      child.once("exit", () => clearTimeout(killTimer));
+    }
+  } else if (process.platform === "win32") {
+    child.kill();
+  } else {
+    child.kill("SIGTERM");
+  }
+}
+function formatExit(code, signal) {
+  if (signal) return `signal ${signal}`;
+  return `code ${code ?? "unknown"}`;
+}
+
+// src/inhibitors.ts
+import { existsSync } from "node:fs";
+import path from "node:path";
+import process2 from "node:process";
+function getInhibitorCommand(mode) {
+  const customCommand = process2.env.PI_CAFFEINATE_COMMAND?.trim();
+  if (customCommand) {
+    const [command, ...args] = splitCommand(customCommand);
+    if (command) return { command, args, description: `custom command (${command})`, custom: true };
+  }
+  if (process2.platform === "darwin") {
+    return parentBoundUnixCommand(
+      "caffeinate",
+      macCaffeinateArgs(mode),
+      caffeinateDescription(mode)
+    );
+  }
+  if (process2.platform === "linux") {
+    if (isWsl() && commandExists("powershell.exe")) {
+      return windowsPowerInhibitorCommand("powershell.exe", mode);
+    }
+    if (commandExists("systemd-inhibit")) {
+      const what = mode === "display" ? "idle:sleep" : "sleep";
+      return parentBoundUnixCommand(
+        "systemd-inhibit",
+        [
+          `--what=${what}`,
+          "--who=pi-caffeinate",
+          "--why=Pi agent is running",
+          "--mode=block",
+          "sleep",
+          "infinity"
+        ],
+        `systemd-inhibit (${formatMode(mode)})`,
+        mode === "display"
+      );
+    }
+    if (commandExists("caffeinate")) {
+      return parentBoundUnixCommand(
+        "caffeinate",
+        macCaffeinateArgs(mode),
+        caffeinateDescription(mode),
+        mode === "display"
+      );
+    }
+  }
+  if (process2.platform === "win32") return windowsPowerInhibitorCommand("powershell.exe", mode);
+  return void 0;
+}
+function macCaffeinateArgs(mode) {
+  return mode === "sleep" ? ["-ims"] : ["-dimsu"];
+}
+function caffeinateDescription(mode) {
+  return `caffeinate (${formatMode(mode)})`;
+}
+function parentBoundUnixCommand(command, args, description, addDbusIdleInhibit = false) {
+  return {
+    command: "sh",
+    args: [
+      "-c",
+      unixParentBoundScript(),
+      "pi-caffeinate-watch",
+      String(process2.pid),
+      command,
+      ...args
+    ],
+    description,
+    ...addDbusIdleInhibit ? { addDbusIdleInhibit: true } : {}
+  };
+}
+function unixParentBoundScript() {
+  return `parent=$1; shift; "$@" & child=$!; ( while kill -0 "$parent" 2>/dev/null; do sleep 5; done; kill "$child" 2>/dev/null ) & watcher=$!; cleanup() { kill "$watcher" 2>/dev/null; kill "$child" 2>/dev/null; wait "$child" 2>/dev/null; }; trap 'cleanup; exit 0' INT TERM HUP EXIT; wait "$child"; status=$?; kill "$watcher" 2>/dev/null; trap - EXIT; exit "$status"`;
+}
+function commandExists(command) {
+  const searchPath = process2.env.PATH ?? "";
+  const extensions = process2.platform === "win32" ? ["", ".exe", ".cmd", ".bat"] : [""];
+  for (const directory of searchPath.split(process2.platform === "win32" ? ";" : ":")) {
+    if (!directory) continue;
+    for (const extension of extensions) {
+      if (existsSync(path.join(directory, `${command}${extension}`))) return true;
+    }
+  }
+  return false;
+}
+function splitCommand(input) {
+  const parts = [];
+  let current = "";
+  let quote;
+  let escaping = false;
+  for (const char of input) {
+    if (escaping) {
+      current += char;
+      escaping = false;
+      continue;
+    }
+    if (char === "\\") {
+      escaping = true;
+      continue;
+    }
+    if ((char === '"' || char === "'") && !quote) {
+      quote = char;
+      continue;
+    }
+    if (char === quote) {
+      quote = void 0;
+      continue;
+    }
+    if (/\s/.test(char) && !quote) {
+      if (current) {
+        parts.push(current);
+        current = "";
+      }
+      continue;
+    }
+    current += char;
+  }
+  if (current) parts.push(current);
+  return parts;
+}
+function windowsPowerInhibitorCommand(command, mode) {
+  return {
+    command,
+    args: ["-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", windowsInhibitorScript(mode)],
+    description: `PowerShell SetThreadExecutionState (${formatMode(mode)})`,
+    releaseOnStdinClose: true
+  };
+}
+function windowsInhibitorScript(mode) {
+  const flags = mode === "sleep" ? "0x80000001" : "0x80000003";
+  return `$ErrorActionPreference = 'Stop'; Add-Type -Namespace Native -Name Power -MemberDefinition '[DllImport("kernel32.dll")] public static extern uint SetThreadExecutionState(uint esFlags);'; $flags = [uint32]'${flags}'; $release = [uint32]'0x80000000'; $stdin = [Console]::OpenStandardInput(); $buffer = New-Object byte[] 1; $readTask = $stdin.ReadAsync($buffer, 0, 1); try { while ($true) { [Native.Power]::SetThreadExecutionState($flags) | Out-Null; if ($readTask.Wait(30000)) { break } } } finally { [Native.Power]::SetThreadExecutionState($release) | Out-Null }`;
+}
+function isWsl() {
+  try {
+    return existsSync("/proc/sys/fs/binfmt_misc/WSLInterop");
+  } catch {
+    return false;
+  }
+}
+function formatMode(mode) {
+  return mode === "sleep" ? "system-awake" : "display-awake";
+}
+
+// src/settings.ts
+import { randomUUID } from "node:crypto";
+import { constants } from "node:fs";
+import { access, lstat, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import process3 from "node:process";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+var NEW_SETTINGS_FILE = "pi-caffeinate.json";
+var LEGACY_SETTINGS_FILE = "pi-caffeinate-settings.json";
+var DEFAULT_FILE_OPERATIONS = {
+  write: (path2, data) => writeFile(path2, data, "utf8").then(() => void 0),
+  rename
+};
+async function loadSettings() {
+  await settingsSaveQueue;
+  const newPath = settingsFilePath();
+  const newSettings = await readSettingsFile(newPath);
+  if (newSettings.kind !== "missing") return withLegacyIgnoredNotice(newSettings);
+  const legacyPath = legacySettingsFilePath();
+  const legacySettings = await readSettingsFile(legacyPath);
+  const concurrentlyCreatedSettings = await readSettingsFile(newPath);
+  if (concurrentlyCreatedSettings.kind !== "missing") {
+    return withLegacyIgnoredNotice(concurrentlyCreatedSettings);
+  }
+  if (legacySettings.kind === "missing") return { kind: "missing" };
+  if (legacySettings.kind === "invalid") return legacySettings;
+  return {
+    ...legacySettings,
+    notice: `Using legacy ${LEGACY_SETTINGS_FILE}; rename it to ${NEW_SETTINGS_FILE}. Future saves write ${NEW_SETTINGS_FILE} without modifying the legacy file.`
+  };
+}
+async function readSettingsDocument(filePath) {
+  let text;
+  try {
+    text = await readFile(filePath, "utf8");
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") return { result: { kind: "missing" } };
+    return { result: { kind: "invalid", reason: `${filePath}: ${formatError2(error)}` } };
+  }
+  try {
+    const document = JSON.parse(text);
+    const settings = normalizeCaffeinateSettings(document);
+    if (settings) {
+      return {
+        result: { kind: "loaded", settings },
+        document: { ...document }
+      };
+    }
+    return {
+      result: {
+        kind: "invalid",
+        reason: `${filePath}: expected { "mode": "sleep" | "display", optional "quiet": boolean }`
+      }
+    };
+  } catch (error) {
+    return { result: { kind: "invalid", reason: `${filePath}: ${formatError2(error)}` } };
+  }
+}
+async function readSettingsFile(filePath) {
+  return (await readSettingsDocument(filePath)).result;
+}
+async function withLegacyIgnoredNotice(settings) {
+  if (!await fileExists(legacySettingsFilePath())) return settings;
+  return {
+    ...settings,
+    notice: `pi-caffeinate legacy settings ignored: ${legacySettingsFilePath()} exists, but ${settingsFilePath()} takes precedence. Delete ${LEGACY_SETTINGS_FILE} after confirming your settings.`
+  };
+}
+async function fileExists(filePath) {
+  try {
+    await access(filePath, constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function pathEntryExists(filePath) {
+  try {
+    await lstat(filePath);
+    return true;
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") return false;
+    throw error;
+  }
+}
+function normalizeCaffeinateSettings(value) {
+  if (!value || typeof value !== "object") return void 0;
+  const settings = value;
+  if (!isCaffeinateMode(settings.mode)) return void 0;
+  if (settings.quiet !== void 0 && typeof settings.quiet !== "boolean") return void 0;
+  if (settings.updatedAt !== void 0 && typeof settings.updatedAt !== "number") return void 0;
+  return {
+    mode: settings.mode,
+    quiet: settings.quiet ?? false,
+    updatedAt: settings.updatedAt ?? 0
+  };
+}
+function isCaffeinateMode(value) {
+  return value === "sleep" || value === "display";
+}
+var settingsSaveQueue = Promise.resolve();
+function saveSettings(settings, operations = {}) {
+  const operation = settingsSaveQueue.then(() => saveSettingsNow(settings, operations));
+  settingsSaveQueue = operation.catch(() => void 0);
+  return operation;
+}
+async function saveSettingsNow(settings, operations) {
+  const filePath = settingsFilePath();
+  let current = await readSettingsDocument(filePath);
+  const replaceCanonical = current.result.kind !== "missing";
+  if (!replaceCanonical) current = await readSettingsDocument(legacySettingsFilePath());
+  if (current.result.kind === "invalid") {
+    throw new Error(`Cannot save pi-caffeinate settings until you repair ${current.result.reason}`);
+  }
+  const document = current.document ?? {};
+  const quiet = settings.quiet ?? (current.result.kind === "loaded" ? current.result.settings.quiet : false);
+  const nextSettings = { mode: settings.mode, quiet, updatedAt: settings.updatedAt };
+  const nextDocument = {
+    ...document,
+    ...nextSettings
+  };
+  await mkdir(dirname(filePath), { recursive: true });
+  const tempFile = `${filePath}.${process3.pid}.${randomUUID()}.tmp`;
+  try {
+    await (operations.write ?? DEFAULT_FILE_OPERATIONS.write)(
+      tempFile,
+      `${JSON.stringify(nextDocument, null, 2)}
+`
+    );
+    if (!replaceCanonical && await pathEntryExists(filePath)) {
+      throw new Error(`${NEW_SETTINGS_FILE} was created concurrently; reopen settings and retry.`);
+    }
+    await (operations.rename ?? DEFAULT_FILE_OPERATIONS.rename)(tempFile, filePath);
+    return nextSettings;
+  } catch (error) {
+    await rm(tempFile, { force: true }).catch(() => void 0);
+    throw error;
+  }
+}
+function settingsFilePath() {
+  return join(agentDir(), NEW_SETTINGS_FILE);
+}
+function legacySettingsFilePath() {
+  return join(agentDir(), LEGACY_SETTINGS_FILE);
+}
+function agentDir() {
+  return getAgentDir();
+}
+function isNodeError(error) {
+  return error instanceof Error && "code" in error;
+}
+function formatError2(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/caffeinate.ts
+var STATUS_KEY = "caffeinate";
+var DISABLED_VALUES = /* @__PURE__ */ new Set(["1", "true", "yes", "on"]);
+var DEFAULT_MODE = "display";
+var COMMAND_COMPLETIONS = [
+  { value: "display", label: "display", description: "Keep system and display awake" },
+  { value: "sleep", label: "sleep", description: "Keep system awake; allow display sleep" },
+  { value: "status", label: "status", description: "Show current status" },
+  { value: "mode", label: "mode", description: "Choose keep-awake mode" },
+  { value: "stop", label: "stop", description: "Release inhibitor for now" },
+  { value: "help", label: "help", description: "Show command help" }
+];
+var MENU_OPTIONS = {
+  display: "Keep system and display awake",
+  sleep: "Keep system awake; allow display sleep",
+  status: "Show current status",
+  stop: "Release inhibitor for now",
+  help: "Show command help"
+};
+var MODE_OPTIONS = {
+  display: "Keep system and display awake",
+  sleep: "Keep system awake; allow display sleep"
+};
+var state = {
+  activeTurns: 0,
+  available: true,
+  inhibitorStarting: false,
+  disabled: isDisabled(),
+  mode: DEFAULT_MODE,
+  quiet: false,
+  settingsLoaded: false,
+  iconWarningShown: false,
+  sessionGeneration: 0,
+  menuController: new AbortController()
+};
+var dbusFactory = defaultDbusScreenSaverFactory;
+var inhibitSequence = 0;
+function caffeinate(pi, options = {}) {
+  dbusFactory = options.dbusFactory ?? defaultDbusScreenSaverFactory;
+  pi.on("session_start", async (_event, ctx) => {
+    const generation = ++state.sessionGeneration;
+    state.currentSession = { generation, ctx };
+    replaceMenuController("Caffeinate session replaced");
+    state.iconWarningShown = false;
+    state.settingsNotice = void 0;
+    warnDeprecatedIcon(ctx);
+    await loadSettingsIntoState(ctx, generation);
+    if (generation !== state.sessionGeneration) return;
+    updateStatus(ctx);
+  });
+  pi.on("agent_start", async (_event, ctx) => {
+    const generation = state.sessionGeneration;
+    await ensureSettingsLoaded(ctx, generation);
+    if (generation !== state.sessionGeneration) return;
+    state.activeTurns += 1;
+    await startInhibitor(ctx, generation, { notify: !state.quiet });
+  });
+  pi.on("agent_end", async (_event, ctx) => {
+    const generation = state.sessionGeneration;
+    state.activeTurns = Math.max(0, state.activeTurns - 1);
+    if (state.activeTurns === 0) {
+      await stopInhibitor(ctx, "agent finished", { notify: !state.quiet });
+    }
+    if (generation !== state.sessionGeneration) return;
+    updateStatus(ctx);
+  });
+  pi.on("session_shutdown", async (_event, ctx) => {
+    const generation = ++state.sessionGeneration;
+    state.currentSession = void 0;
+    state.menuController.abort(new DOMException("Caffeinate session shut down", "AbortError"));
+    state.activeTurns = 0;
+    await stopInhibitor(ctx, "session shutdown", { notify: false });
+    await modeOperationQueue;
+    if (generation !== state.sessionGeneration) return;
+    ctx.ui.setStatus(STATUS_KEY, void 0);
+  });
+  pi.registerCommand("caffeinate", {
+    description: "Open pi-caffeinate keep-awake controls",
+    getArgumentCompletions: (prefix) => commandCompletions(prefix),
+    handler: async (args, ctx) => {
+      const generation = state.sessionGeneration;
+      const command = parseCommand(args);
+      if (command === "sleep" || command === "display") {
+        await setModeAfterSettingsLoad(ctx, command, generation);
+        return;
+      }
+      await ensureSettingsLoaded(ctx, generation);
+      if (generation !== state.sessionGeneration) return;
+      await handleCaffeinateCommand(args, ctx, generation);
+    }
+  });
+}
+async function handleCaffeinateCommand(args, ctx, generation) {
+  const command = parseCommand(args);
+  switch (command) {
+    case "menu":
+      await showMenu(ctx, generation);
+      return;
+    case "help":
+      ctx.ui.notify(buildCommandGuide(), "info");
+      return;
+    case "status":
+      showStatus(ctx);
+      return;
+    case "mode":
+      await showModeSelector(ctx, generation);
+      return;
+    case "sleep":
+      await setMode(ctx, "sleep", generation);
+      return;
+    case "display":
+      await setMode(ctx, "display", generation);
+      return;
+    case "stop":
+      await stopCaffeinate(ctx, "manual stop", generation);
+      return;
+  }
+  ctx.ui.notify(`Unknown /caffeinate command: ${args.trim()}
+
+${buildCommandGuide()}`, "warning");
+}
+async function showMenu(ctx, generation) {
+  await runCaffeinateMenu(ctx, generation, "main");
+}
+async function showModeSelector(ctx, generation) {
+  await runCaffeinateMenu(ctx, generation, "mode");
+}
+async function runCaffeinateMenu(ctx, generation, start) {
+  if (!ctx.hasUI) {
+    throw new Error(
+      start === "mode" ? "Mode selection requires TUI or RPC mode. Use /caffeinate sleep or /caffeinate display." : `The pi-caffeinate menu requires TUI or RPC mode.
+
+${buildCommandGuide()}
+
+${describeState()}`
+    );
+  }
+  const menuSignal = state.menuController.signal;
+  const isCurrent = () => generation === state.sessionGeneration && !menuSignal.aborted;
+  const { defineMenu, runMenu } = await import("@narumitw/pi-tui-kit");
+  if (!isCurrent()) return;
+  const menu = defineMenu({
+    start,
+    screens: {
+      main: () => ({
+        kind: "actions",
+        title: "pi-caffeinate controls",
+        lines: describeState().split("\n"),
+        items: Object.entries(MENU_OPTIONS).map(([id, label]) => ({
+          id,
+          label,
+          action: id
+        })),
+        hint: "close"
+      }),
+      mode: () => ({
+        kind: "actions",
+        title: `pi-caffeinate mode (current: ${formatMode(state.mode)})`,
+        items: Object.entries(MODE_OPTIONS).map(([id, label]) => ({
+          id,
+          label,
+          action: id
+        })),
+        hint: "close"
+      })
+    },
+    actions: {
+      display: async () => {
+        await setMode(ctx, "display", generation);
+        return { kind: "close" };
+      },
+      sleep: async () => {
+        await setMode(ctx, "sleep", generation);
+        return { kind: "close" };
+      },
+      status: async () => {
+        showStatus(ctx);
+        return { kind: "close" };
+      },
+      stop: async () => {
+        await stopCaffeinate(ctx, "manual stop", generation);
+        return { kind: "close" };
+      },
+      help: async () => {
+        ctx.ui.notify(buildCommandGuide(), "info");
+        return { kind: "close" };
+      }
+    }
+  });
+  await runMenu(ctx, menu, {
+    getState: () => void 0,
+    signal: menuSignal,
+    isCurrent
+  });
+}
+function replaceMenuController(reason) {
+  state.menuController.abort(new DOMException(reason, "AbortError"));
+  state.menuController = new AbortController();
+}
+var modeOperationQueue = Promise.resolve();
+function setModeAfterSettingsLoad(ctx, mode, generation) {
+  return enqueueModeOperation(async () => {
+    await ensureSettingsLoaded(ctx, generation);
+    if (generation !== state.sessionGeneration) return;
+    await setModeNow(ctx, mode, generation);
+  });
+}
+function setMode(ctx, mode, generation) {
+  return enqueueModeOperation(() => setModeNow(ctx, mode, generation));
+}
+function enqueueModeOperation(operation) {
+  const queued = modeOperationQueue.then(operation);
+  modeOperationQueue = queued.catch(() => void 0);
+  return queued;
+}
+async function setModeNow(ctx, mode, generation) {
+  if (generation !== state.sessionGeneration) return;
+  const previousMode = state.mode;
+  const previousQuiet = state.quiet;
+  const restartRequired = Boolean(
+    hasActiveInhibitor() && previousMode !== mode && !state.command?.custom
+  );
+  state.settingsError = void 0;
+  if (restartRequired) {
+    state.mode = mode;
+    await stopInhibitor(ctx, "mode changed", { notify: false });
+    if (generation !== state.sessionGeneration) return;
+    await startInhibitor(ctx, generation, { notify: false });
+    if (generation !== state.sessionGeneration) return;
+    if (!hasActiveInhibitor()) {
+      const applicationError = state.lastError ?? "the inhibitor could not be restarted";
+      state.mode = previousMode;
+      await startInhibitor(ctx, generation, { notify: false });
+      if (generation !== state.sessionGeneration) return;
+      const rollbackError = hasActiveInhibitor() ? void 0 : state.lastError ?? "the previous inhibitor could not be restored";
+      state.settingsError = rollbackError ? `mode application failed (${applicationError}); runtime rollback failed: ${rollbackError}` : `mode application failed and was rolled back: ${applicationError}`;
+      ctx.ui.notify(`pi-caffeinate ${state.settingsError}`, "warning");
+      updateStatus(ctx);
+      return;
+    }
+  }
+  let savedSettings;
+  try {
+    savedSettings = await saveSettings({ mode, updatedAt: Date.now() });
+  } catch (error) {
+    if (generation !== state.sessionGeneration) return;
+    let rollbackError;
+    if (restartRequired) {
+      state.mode = previousMode;
+      state.quiet = previousQuiet;
+      await stopInhibitor(ctx, "settings save failed", { notify: false });
+      if (generation !== state.sessionGeneration) return;
+      await startInhibitor(ctx, generation, { notify: false });
+      if (generation !== state.sessionGeneration) return;
+      if (!hasActiveInhibitor()) {
+        rollbackError = state.lastError ?? "the prior inhibitor was not restored";
+      }
+    }
+    state.settingsError = rollbackError ? `settings save failed (${formatError3(error)}); runtime rollback failed: ${rollbackError}` : `settings save failed: ${formatError3(error)}`;
+    ctx.ui.notify(
+      `pi-caffeinate mode remains ${formatMode(previousMode)}; settings were not saved: ${state.settingsError}`,
+      "warning"
+    );
+    updateStatus(ctx);
+    return;
+  }
+  if (generation !== state.sessionGeneration) return;
+  state.mode = mode;
+  state.quiet = savedSettings.quiet;
+  ctx.ui.notify(`pi-caffeinate mode set to ${formatMode(mode)} and saved.`, "info");
+  updateStatus(ctx);
+}
+function showStatus(ctx) {
+  ctx.ui.notify(describeState(), statusLevel());
+  updateStatus(ctx);
+}
+async function stopCaffeinate(ctx, reason, sessionGeneration) {
+  state.activeTurns = 0;
+  await stopInhibitor(ctx, reason);
+  if (sessionGeneration !== state.sessionGeneration) return;
+  updateStatus(ctx);
+}
+function parseCommand(args) {
+  const command = args.trim().toLowerCase();
+  if (!command) return "menu";
+  if (command === "help") return "help";
+  if (command === "status") return "status";
+  if (command === "mode" || command === "config" || command === "settings") return "mode";
+  if (command === "sleep" || command === "system") return "sleep";
+  if (command === "display" || command === "screen") return "display";
+  if (command === "stop" || command === "off") return "stop";
+  return "unknown";
+}
+function commandCompletions(prefix) {
+  const normalized = prefix.trimStart().toLowerCase();
+  if (/\s/.test(normalized)) return null;
+  const matches = COMMAND_COMPLETIONS.filter(
+    (completion) => completion.value.startsWith(normalized)
+  );
+  return matches.length > 0 ? matches : null;
+}
+function buildCommandGuide() {
+  return [
+    "pi-caffeinate commands:",
+    "/caffeinate \u2014 open keep-awake controls",
+    "/caffeinate display \u2014 keep the system and display awake",
+    "/caffeinate sleep \u2014 keep the system awake while allowing display sleep",
+    "/caffeinate status \u2014 show current mode, settings, and inhibitor state",
+    "/caffeinate mode \u2014 choose a keep-awake mode",
+    "/caffeinate stop \u2014 release the active inhibitor until the next agent run"
+  ].join("\n");
+}
+async function startInhibitor(ctx, sessionGeneration, options = {}) {
+  if (state.disabled || hasActiveInhibitor() || state.inhibitorStarting) {
+    updateStatus(ctx);
+    return;
+  }
+  const token = ++inhibitSequence;
+  const command = getInhibitorCommand(state.mode);
+  const wantsDbus = !command?.custom && state.mode === "display" && process4.platform === "linux" && (command === void 0 || command.addDbusIdleInhibit === true);
+  if (!command && !wantsDbus) {
+    state.available = false;
+    state.lastError = `No supported sleep inhibitor found for ${process4.platform}.`;
+    ctx.ui.notify(state.lastError, "warning");
+    updateStatus(ctx);
+    return;
+  }
+  state.inhibitorStarting = true;
+  state.inhibitWarning = void 0;
+  let child;
+  let childError = !command && wantsDbus ? "No supported system sleep inhibitor is available; direct system suspend may remain possible." : void 0;
+  let assembling = true;
+  const handleChildFailure = (message) => {
+    if (!child || token !== inhibitSequence || state.process !== child) return;
+    state.process = void 0;
+    state.command = void 0;
+    if (assembling) {
+      childError = message;
+      return;
+    }
+    applyChildFailure(message);
+  };
+  if (command) {
+    try {
+      child = startInhibitorProcess(
+        command,
+        (error) => handleChildFailure(`${command.description} failed: ${error.message}`),
+        (exit) => handleChildFailure(`${command.description} exited unexpectedly (${exit}).`)
+      );
+      state.process = child;
+      state.command = command;
+      state.startedAt = Date.now();
+    } catch (error) {
+      childError = `${command.description}: ${formatError3(error)}`;
+    }
+  }
+  let dbus;
+  let dbusError;
+  if (wantsDbus) {
+    const pending = { token, controller: new AbortController() };
+    state.pendingDbus = pending;
+    try {
+      const client = await dbusFactory();
+      if (!pendingStartIsCurrent(pending, sessionGeneration)) {
+        await client.close().catch(() => void 0);
+        await cancelPendingStart(token, child, command);
+        return;
+      }
+      pending.client = client;
+      await client.inhibit(INHIBIT_REASON, pending.controller.signal);
+      if (!pendingStartIsCurrent(pending, sessionGeneration)) {
+        await cancelPendingStart(token, child, command);
+        return;
+      }
+      pending.client = void 0;
+      state.pendingDbus = void 0;
+      dbus = client;
+    } catch (error) {
+      const stale = !pendingStartIsCurrent(pending, sessionGeneration) || pending.controller.signal.aborted;
+      const pendingClient = takePendingDbusClient(pending);
+      await pendingClient?.close().catch(() => void 0);
+      if (stale) {
+        await cancelPendingStart(token, child, command);
+        return;
+      }
+      dbusError = `D-Bus idle inhibit (${SCREENSAVER_BUS_NAME}): ${formatError3(error)}`;
+    }
+  }
+  assembling = false;
+  if (startIsStale(token, sessionGeneration)) {
+    await cancelPendingStart(token, child, command);
+    await dbus?.close().catch(() => void 0);
+    return;
+  }
+  state.inhibitorStarting = false;
+  state.dbus = dbus;
+  if (dbus) {
+    dbus.setFailureHandler((error) => applyDbusFailure(token, dbus, error));
+    if (state.dbus !== dbus) return;
+  }
+  const failures = [childError, dbusError].filter((failure) => Boolean(failure));
+  if (!hasActiveInhibitor()) {
+    state.startedAt = void 0;
+    state.command = void 0;
+    state.available = false;
+    state.lastError = failures.join("; ") || `No supported sleep inhibitor found for ${process4.platform}.`;
+    ctx.ui.notify(state.lastError, "warning");
+    updateStatus(ctx);
+    return;
+  }
+  state.startedAt ??= Date.now();
+  state.available = true;
+  state.lastError = void 0;
+  state.inhibitWarning = failures.length > 0 ? failures.join("; ") : void 0;
+  if (state.inhibitWarning) {
+    ctx.ui.notify(`pi-caffeinate is partially active: ${state.inhibitWarning}`, "warning");
+  } else if (options.notify !== false) {
+    ctx.ui.notify(`Keeping computer awake (${statusModeLabel()}).`, "info");
+  }
+  updateStatus(ctx);
+}
+async function stopInhibitor(ctx, reason, options = {}) {
+  inhibitSequence += 1;
+  const child = state.process;
+  const dbus = state.dbus;
+  const dbusCleanup = state.dbusCleanup;
+  const pending = state.pendingDbus;
+  const command = state.command;
+  const wasStarting = state.inhibitorStarting;
+  state.process = void 0;
+  state.dbus = void 0;
+  state.dbusCleanup = void 0;
+  state.pendingDbus = void 0;
+  state.command = void 0;
+  state.startedAt = void 0;
+  state.inhibitWarning = void 0;
+  state.inhibitorStarting = false;
+  dbus?.setFailureHandler(void 0);
+  pending?.controller.abort(new DOMException(`Caffeinate stopped: ${reason}`, "AbortError"));
+  const pendingClient = pending ? takePendingDbusClient(pending) : void 0;
+  if (child) stopInhibitorProcess(child, command);
+  if (!child && !dbus && !pendingClient && !wasStarting) {
+    await dbusCleanup;
+    return;
+  }
+  if (options.notify !== false) ctx.ui.notify(`Released pi-caffeinate (${reason}).`, "info");
+  await Promise.all([dbusCleanup, pendingClient?.close().catch(() => void 0)]);
+  if (!dbus) return;
+  try {
+    await dbus.uninhibit();
+  } catch {
+  }
+  await dbus.close().catch(() => void 0);
+}
+function applyChildFailure(message) {
+  if (state.dbus) {
+    state.available = true;
+    state.lastError = void 0;
+    state.inhibitWarning = message;
+  } else {
+    state.startedAt = void 0;
+    state.available = false;
+    state.lastError = message;
+    state.inhibitWarning = void 0;
+  }
+  const ctx = currentSessionContext();
+  if (!ctx) return;
+  ctx.ui.notify(message, "warning");
+  updateStatus(ctx);
+}
+function applyDbusFailure(token, client, error) {
+  if (token !== inhibitSequence || state.dbus !== client) return;
+  client.setFailureHandler(void 0);
+  state.dbus = void 0;
+  const message = `D-Bus idle inhibit (${SCREENSAVER_BUS_NAME}) failed: ${formatError3(error)}`;
+  const notification = state.process ? `pi-caffeinate is partially active: ${message}` : message;
+  if (state.process) {
+    state.available = true;
+    state.lastError = void 0;
+    state.inhibitWarning = message;
+  } else {
+    state.startedAt = void 0;
+    state.command = void 0;
+    state.available = false;
+    state.lastError = [state.inhibitWarning, message].filter(Boolean).join("; ");
+    state.inhibitWarning = void 0;
+  }
+  const cleanup = client.close().catch(() => void 0);
+  state.dbusCleanup = cleanup;
+  void cleanup.then(() => {
+    if (state.dbusCleanup === cleanup) state.dbusCleanup = void 0;
+  });
+  const ctx = currentSessionContext();
+  if (!ctx) return;
+  ctx.ui.notify(notification, "warning");
+  updateStatus(ctx);
+}
+function currentSessionContext() {
+  const session = state.currentSession;
+  return session?.generation === state.sessionGeneration ? session.ctx : void 0;
+}
+function hasActiveInhibitor() {
+  return Boolean(state.process || state.dbus);
+}
+function startIsStale(token, sessionGeneration) {
+  return token !== inhibitSequence || sessionGeneration !== state.sessionGeneration;
+}
+function pendingStartIsCurrent(pending, sessionGeneration) {
+  return state.pendingDbus === pending && !pending.controller.signal.aborted && !startIsStale(pending.token, sessionGeneration);
+}
+function takePendingDbusClient(pending) {
+  if (state.pendingDbus === pending) state.pendingDbus = void 0;
+  const client = pending.client;
+  pending.client = void 0;
+  return client;
+}
+async function cancelPendingStart(token, child, command) {
+  if (token !== inhibitSequence) return;
+  inhibitSequence += 1;
+  state.inhibitorStarting = false;
+  const pending = state.pendingDbus?.token === token ? state.pendingDbus : void 0;
+  state.pendingDbus = void 0;
+  pending?.controller.abort(new DOMException("Caffeinate start cancelled", "AbortError"));
+  const pendingClient = pending ? takePendingDbusClient(pending) : void 0;
+  if (child && state.process === child) {
+    state.process = void 0;
+    state.command = void 0;
+    state.startedAt = void 0;
+    stopInhibitorProcess(child, command);
+  }
+  await pendingClient?.close().catch(() => void 0);
+}
+function updateStatus(ctx) {
+  if (state.disabled || state.quiet) {
+    ctx.ui.setStatus(STATUS_KEY, void 0);
+    return;
+  }
+  if (hasActiveInhibitor()) {
+    ctx.ui.setStatus(STATUS_KEY, withDeprecatedIcon(statusModeLabel()));
+    return;
+  }
+  if (!state.available) {
+    ctx.ui.setStatus(STATUS_KEY, withDeprecatedIcon("unavailable"));
+    return;
+  }
+  ctx.ui.setStatus(STATUS_KEY, void 0);
+}
+function describeState() {
+  const customCommand = hasCustomCommand();
+  const lines = [
+    `Mode: ${formatMode(state.mode)}${customCommand ? " (overridden by custom command)" : ""}`,
+    `Quiet mode: ${state.quiet ? "enabled" : "disabled"}`,
+    `Settings: ${settingsFilePath()}`
+  ];
+  if (customCommand) lines.push("Custom command: PI_CAFFEINATE_COMMAND overrides the saved mode.");
+  if (state.settingsNotice) lines.push(`Settings note: ${state.settingsNotice}`);
+  if (state.settingsError) lines.push(`Settings warning: ${state.settingsError}`);
+  if (state.disabled) {
+    lines.unshift("pi-caffeinate is disabled by PI_CAFFEINATE_DISABLED.");
+    return lines.join("\n");
+  }
+  if (hasActiveInhibitor()) {
+    const seconds = state.startedAt ? Math.round((Date.now() - state.startedAt) / 1e3) : 0;
+    const activeParts = [];
+    if (state.dbus) activeParts.push(`D-Bus idle inhibit (${SCREENSAVER_BUS_NAME})`);
+    if (state.process && state.command) activeParts.push(state.command.description);
+    lines.unshift(
+      `pi-caffeinate is active using ${activeParts.join(" + ") || "an inhibitor"} for ${seconds}s.`
+    );
+    if (state.inhibitWarning) lines.push(`Inhibitor warning: ${state.inhibitWarning}`);
+    return lines.join("\n");
+  }
+  if (!state.available) {
+    lines.unshift(`pi-caffeinate is unavailable: ${state.lastError ?? "unknown reason"}`);
+    return lines.join("\n");
+  }
+  lines.unshift(
+    "pi-caffeinate is idle and will keep the computer awake during the next agent run."
+  );
+  return lines.join("\n");
+}
+function statusLevel() {
+  return state.available && !state.settingsError && !state.inhibitWarning ? "info" : "warning";
+}
+function statusModeLabel() {
+  if (state.command?.custom) return "custom";
+  return formatMode(state.mode);
+}
+async function ensureSettingsLoaded(ctx, generation) {
+  if (state.disabled || state.settingsLoaded) return;
+  await loadSettingsIntoState(ctx, generation);
+}
+async function loadSettingsIntoState(ctx, generation) {
+  if (state.disabled) {
+    state.settingsLoaded = true;
+    state.settingsError = void 0;
+    state.quiet = false;
+    return;
+  }
+  const settings = await loadSettings();
+  if (generation !== state.sessionGeneration) return;
+  state.settingsLoaded = true;
+  state.settingsError = void 0;
+  if (settings.notice) {
+    state.settingsNotice = settings.notice;
+    ctx.ui.notify(settings.notice, "warning");
+  }
+  if (settings.kind === "loaded") {
+    state.mode = settings.settings.mode;
+    state.quiet = settings.settings.quiet;
+    return;
+  }
+  state.mode = DEFAULT_MODE;
+  state.quiet = false;
+  if (settings.kind === "invalid") {
+    state.settingsError = settings.reason;
+    ctx.ui.notify(
+      `pi-caffeinate settings ignored: ${settings.reason}; using ${formatMode(DEFAULT_MODE)} mode.`,
+      "warning"
+    );
+  }
+}
+function formatError3(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function isDisabled() {
+  const value = process4.env.PI_CAFFEINATE_DISABLED?.trim().toLowerCase();
+  return value ? DISABLED_VALUES.has(value) : false;
+}
+function hasCustomCommand() {
+  return Boolean(process4.env.PI_CAFFEINATE_COMMAND?.trim());
+}
+function withDeprecatedIcon(text) {
+  const icon = process4.env.PI_CAFFEINATE_ICON?.trim();
+  return icon ? `${icon} ${text}` : text;
+}
+function warnDeprecatedIcon(ctx) {
+  if (state.iconWarningShown || !process4.env.PI_CAFFEINATE_ICON?.trim()) return;
+  state.iconWarningShown = true;
+  ctx.ui.notify(
+    "PI_CAFFEINATE_ICON is deprecated but still works for now. If you use @narumitw/pi-statusline, move it to pi-statusline.json (extensionStatusIcons.caffeinate).",
+    "warning"
+  );
+}
+export {
+  caffeinate as default
+};
+//# sourceMappingURL=index.ts.map