@lunora/cli 1.0.0-alpha.3 → 1.0.0-alpha.30

package/dist/packem_shared/tui-prompts-BjEN8XgP.mjs

@@ -0,0 +1,658 @@
+import { jsx, jsxs } from 'react/jsx-runtime';
+import { isInteractive, ACCENT, LUNA_ART, LUNA_NAME, LUNA_SIGNOFF, BADGE_COLUMN_WIDTH, badgeLead, padBadge, badgeWidth } from '@lunora/config';
+import { render } from '@visulima/tui';
+import '@visulima/tui/components/big-text';
+import { Box } from '@visulima/tui/components/box';
+import { CommandPalette } from '@visulima/tui/components/command-palette';
+import { ConfirmInput } from '@visulima/tui/components/confirm-input';
+import { SelectInput } from '@visulima/tui/components/select-input';
+import { Spinner } from '@visulima/tui/components/spinner';
+import { Text } from '@visulima/tui/components/text';
+import { TextInput } from '@visulima/tui/components/text-input';
+import { useApp } from '@visulima/tui/hooks/use-app';
+import { useInput } from '@visulima/tui/hooks/use-input';
+import { useInterval } from '@visulima/tui/hooks/use-interval';
+import { useEffect, useState } from 'react';
+import { P as PromptCancelledError } from './prompt-cancelled-APzX1Im-.mjs';
+
+let listenerCapRaised = false;
+const raiseListenerCap = () => {
+  if (listenerCapRaised) {
+    return;
+  }
+  listenerCapRaised = true;
+  if (process.getMaxListeners() < 64) {
+    process.setMaxListeners(64);
+  }
+};
+const CtrlCGuard = ({ children, onCancel }) => {
+  const { exit } = useApp();
+  useInput((input, key) => {
+    if (key.ctrl && input === "c") {
+      onCancel();
+      exit();
+    }
+  });
+  return children;
+};
+const toError = (failure) => {
+  if (failure instanceof Error) {
+    return failure;
+  }
+  return new Error(typeof failure === "string" ? failure : "task failed");
+};
+const SCROLL_LIMIT = 10;
+const FILTER_THRESHOLD = 8;
+const Badge = ({ spec }) => jsxs(Text, { children: [
+  jsx(Text, { children: badgeLead(spec.text) }),
+  jsx(Text, { backgroundColor: spec.bg, bold: true, color: spec.fg, children: padBadge(spec.text) })
+] });
+const PromptHeader = ({ badge, message }) => badge === void 0 ? jsx(Text, { bold: true, children: message }) : jsxs(Box, { children: [
+  jsx(Badge, { spec: badge }),
+  jsx(Text, { bold: true, children: ` ${message}` })
+] });
+const BODY_INDENT = 2;
+const HEADER_INDENT = " ".repeat(BADGE_COLUMN_WIDTH - 1);
+const badgeIndent = (badge) => " ".repeat(badgeWidth(badge) + 1);
+const bodyIndent = (badge) => badge === void 0 ? BODY_INDENT : badgeWidth(badge) + 1;
+const PromptShell = ({
+  badge,
+  children,
+  message
+}) => jsxs(Box, { flexDirection: "column", children: [
+  jsx(PromptHeader, { badge, message }),
+  jsx(Box, { flexDirection: "column", marginLeft: bodyIndent(badge), children })
+] });
+const AnsweredLine = ({ answer, badge, message }) => jsxs(Box, { flexDirection: "column", children: [
+  jsx(PromptHeader, { badge, message }),
+  answer === "" ? null : jsx(Text, { dimColor: true, children: `${badge === void 0 ? " ".repeat(BODY_INDENT) : badgeIndent(badge)}${answer}` })
+] });
+const useAnswer = (finish) => {
+  const { exit } = useApp();
+  const [answer, setAnswer] = useState(void 0);
+  useEffect(() => {
+    if (answer !== void 0) {
+      exit();
+    }
+  }, [answer, exit]);
+  return {
+    answer,
+    submit: (result, display) => {
+      finish(result);
+      setAnswer(display);
+    }
+  };
+};
+const SelfExit = ({ children }) => {
+  const { exit } = useApp();
+  useEffect(() => {
+    exit();
+  }, [exit]);
+  return children;
+};
+const printFrame = async (element) => {
+  raiseListenerCap();
+  process.stdout.write("\n");
+  const instance = render(jsx(SelfExit, { children: element }));
+  try {
+    await instance.waitUntilExit();
+  } catch {
+  } finally {
+    instance.unmount();
+  }
+};
+const tuiStep = async (badge, message, answer) => {
+  if (!isInteractive()) {
+    return;
+  }
+  const answerLines = answer === void 0 || answer === "" ? [] : answer.split("\n");
+  await printFrame(
+    jsxs(Box, { flexDirection: "column", children: [
+      jsxs(Box, { children: [
+        jsx(Badge, { spec: badge }),
+        jsx(Text, { bold: true, children: ` ${message}` })
+      ] }),
+      answerLines.map((line) => jsx(Text, { dimColor: true, children: `${badgeIndent(badge)}${line}` }, line))
+    ] })
+  );
+};
+const runInkApp = async (element) => {
+  raiseListenerCap();
+  process.stdout.write("\n");
+  const cancel = { value: false };
+  const instance = render(
+    jsx(
+      CtrlCGuard,
+      {
+        onCancel: () => {
+          cancel.value = true;
+        },
+        children: element
+      }
+    ),
+    { exitOnCtrlC: false }
+  );
+  try {
+    await instance.waitUntilExit();
+  } finally {
+    instance.unmount();
+  }
+  if (cancel.value) {
+    throw new PromptCancelledError();
+  }
+};
+const runInkPrompt = async (build, fallback) => {
+  let result = fallback;
+  await runInkApp(
+    build((value) => {
+      result = value;
+    })
+  );
+  return result;
+};
+const itemLabel = (option) => option.description === void 0 ? option.label : `${option.label} — ${option.description}`;
+const useEscapeToExit = () => {
+  const { exit } = useApp();
+  useInput((_input, key) => {
+    if (key.escape) {
+      exit();
+    }
+  });
+};
+const SelectView = ({ badge, finish, initialIndex, message, options }) => {
+  const { answer, submit } = useAnswer(finish);
+  useEscapeToExit();
+  if (answer !== void 0) {
+    return jsx(AnsweredLine, { answer, badge, message });
+  }
+  return jsx(PromptShell, { badge, message, children: jsx(
+    SelectInput,
+    {
+      accentColor: ACCENT,
+      initialIndex,
+      items: options.map((option) => {
+        return { key: option.value, label: itemLabel(option), value: option.value };
+      }),
+      limit: SCROLL_LIMIT,
+      onSelect: (item) => {
+        submit(item.value, options.find((option) => option.value === item.value)?.label ?? item.value);
+      }
+    }
+  ) });
+};
+const PaletteView = ({ badge, finish, message, options }) => {
+  const { exit } = useApp();
+  const { answer, submit } = useAnswer(finish);
+  if (answer !== void 0) {
+    return jsx(AnsweredLine, { answer, badge, message });
+  }
+  return jsx(PromptShell, { badge, message, children: jsx(
+    CommandPalette,
+    {
+      accentColor: ACCENT,
+      autoFocus: true,
+      commands: options.map((option) => {
+        return { description: option.description, id: option.value, label: option.label };
+      }),
+      limit: SCROLL_LIMIT,
+      onCancel: () => {
+        exit();
+      },
+      onSelect: (id) => {
+        submit(id, options.find((option) => option.value === id)?.label ?? id);
+      },
+      placeholder: "Type to filter…"
+    }
+  ) });
+};
+const tuiSelect = async (message, options, settings) => {
+  if (!isInteractive() || options.length === 0) {
+    return settings?.default;
+  }
+  const { badge } = settings ?? {};
+  if (options.length > FILTER_THRESHOLD) {
+    return runInkPrompt((finish) => jsx(PaletteView, { badge, finish, message, options }), settings?.default);
+  }
+  const defaultIndex = settings?.default === void 0 ? -1 : options.findIndex((option) => option.value === settings.default);
+  return runInkPrompt(
+    (finish) => jsx(SelectView, { badge, finish, initialIndex: defaultIndex >= 0 ? defaultIndex : void 0, message, options }),
+    settings?.default
+  );
+};
+const TextView = ({ badge, defaultValue, finish, message, placeholder }) => {
+  const { answer, submit } = useAnswer(finish);
+  useEscapeToExit();
+  if (answer !== void 0) {
+    return jsx(AnsweredLine, { answer, badge, message });
+  }
+  return jsx(PromptShell, { badge, message, children: jsx(
+    TextInput,
+    {
+      defaultValue,
+      onSubmit: (value) => {
+        const chosen = value.trim() === "" ? defaultValue : value.trim();
+        submit(chosen, chosen);
+      },
+      placeholder
+    }
+  ) });
+};
+const tuiText = async (message, settings) => {
+  const fallback = settings?.default ?? "";
+  if (!isInteractive()) {
+    return fallback;
+  }
+  const { badge } = settings ?? {};
+  return runInkPrompt(
+    (finish) => jsx(TextView, { badge, defaultValue: fallback, finish, message, placeholder: settings?.placeholder }),
+    fallback
+  );
+};
+const MultiSelectView = ({ badge, defaults, finish, message, options }) => {
+  const { answer, submit } = useAnswer(finish);
+  const [cursor, setCursor] = useState(0);
+  const [selected, setSelected] = useState(() => new Set(defaults));
+  useEscapeToExit();
+  useInput((input, key) => {
+    if (answer !== void 0 || options.length === 0) {
+      return;
+    }
+    if (key.upArrow) {
+      setCursor((current) => (current - 1 + options.length) % options.length);
+    } else if (key.downArrow) {
+      setCursor((current) => (current + 1) % options.length);
+    } else if (input === " ") {
+      const option = options[cursor];
+      if (option !== void 0) {
+        setSelected((previous) => {
+          const next = new Set(previous);
+          if (next.has(option.value)) {
+            next.delete(option.value);
+          } else {
+            next.add(option.value);
+          }
+          return next;
+        });
+      }
+    } else if (key.return) {
+      const picked = options.filter((option) => selected.has(option.value));
+      submit(
+        picked.map((option) => option.value),
+        picked.length > 0 ? picked.map((option) => option.label).join(", ") : "none"
+      );
+    }
+  });
+  if (answer !== void 0) {
+    return jsx(AnsweredLine, { answer, badge, message });
+  }
+  return jsx(PromptShell, { badge, message, children: jsxs(Box, { flexDirection: "column", children: [
+    jsx(Text, { dimColor: true, children: "space toggles · enter confirms · esc cancels" }),
+    options.map((option, index) => {
+      const onCursor = index === cursor;
+      return jsx(Text, { color: onCursor ? ACCENT : void 0, children: `${onCursor ? "▸ " : "  "}${selected.has(option.value) ? "◼" : "◻"} ${itemLabel(option)}` }, option.value);
+    })
+  ] }) });
+};
+const tuiMultiSelect = async (message, options, settings) => {
+  const defaults = settings?.defaults ?? [];
+  if (!isInteractive() || options.length === 0) {
+    return [...defaults];
+  }
+  const { badge } = settings ?? {};
+  return runInkPrompt(
+    (finish) => jsx(MultiSelectView, { badge, defaults, finish, message, options }),
+    [...defaults]
+  );
+};
+const ConfirmView = ({ badge, defaultYes, finish, message }) => {
+  const { answer, submit } = useAnswer(finish);
+  if (answer !== void 0) {
+    return jsx(AnsweredLine, { answer, badge, message });
+  }
+  return jsxs(Box, { children: [
+    badge === void 0 ? null : jsx(Badge, { spec: badge }),
+    jsx(Text, { bold: true, children: badge === void 0 ? `${message} ` : ` ${message} ` }),
+    jsx(
+      ConfirmInput,
+      {
+        defaultChoice: defaultYes ? "confirm" : "cancel",
+        onCancel: () => {
+          submit(false, "No");
+        },
+        onConfirm: () => {
+          submit(true, "Yes");
+        }
+      }
+    )
+  ] });
+};
+const tuiConfirm = async (message, options) => {
+  const defaultYes = options?.defaultYes === true;
+  if (!isInteractive()) {
+    return defaultYes;
+  }
+  const { badge } = options ?? {};
+  return runInkPrompt((finish) => jsx(ConfirmView, { badge, defaultYes, finish, message }), false);
+};
+const createTuiConfirm = () => isInteractive() ? (message) => tuiConfirm(message, { defaultYes: true }) : () => Promise.resolve(false);
+const STAR_BRIGHT = "#c8a8ff";
+const MOON_LIGHT = "#d9c8ff";
+const MOON_FACE = "#6b5b9a";
+const MoonRow = ({ moon, prefix, suffix }) => jsxs(Box, { children: [
+  jsx(Text, { color: STAR_BRIGHT, dimColor: true, children: prefix }),
+  typeof moon === "string" ? jsx(Text, { color: MOON_LIGHT, children: moon }) : moon,
+  suffix === void 0 ? null : jsx(Text, { color: STAR_BRIGHT, children: suffix })
+] });
+const MoonFace = ({ left, right }) => jsxs(Text, { color: MOON_LIGHT, children: [
+  left,
+  jsx(Text, { color: MOON_FACE, children: "●●" }),
+  right
+] });
+const MoonriseHeader = () => jsxs(Box, { flexDirection: "column", paddingX: 1, children: [
+  jsx(MoonRow, { moon: ".-‐-.", prefix: "·      ✦          ·      ", suffix: "     ✦" }),
+  jsx(MoonRow, { moon: jsx(MoonFace, { left: "/", right: "\\" }), prefix: "      ✦      ·           ", suffix: "   ·" }),
+  jsx(MoonRow, { moon: jsx(MoonFace, { left: "\\", right: "/" }), prefix: "  .        ✦      ·      " }),
+  jsxs(Box, { children: [
+    jsx(Text, { bold: true, color: ACCENT, children: "      lunora init " }),
+    jsx(Text, { dimColor: true, children: "· moonrise sequence" }),
+    jsx(Text, { color: MOON_LIGHT })
+  ] })
+] });
+const tuiMoonrise = async (subtitle) => {
+  if (!isInteractive()) {
+    return;
+  }
+  await printFrame(
+    jsxs(Box, { flexDirection: "column", children: [
+      jsx(MoonriseHeader, {}),
+      jsx(Box, { paddingX: 1, children: jsx(Text, { dimColor: true, children: subtitle }) })
+    ] })
+  );
+};
+const SpinnerView = ({ label }) => jsxs(Box, { children: [
+  jsx(Text, { color: ACCENT, children: jsx(Spinner, { type: "dots" }) }),
+  jsxs(Text, { children: [
+    " ",
+    label
+  ] })
+] });
+const withTuiSpinner = async (label, task) => {
+  if (!isInteractive()) {
+    return task();
+  }
+  raiseListenerCap();
+  const instance = render(jsx(SpinnerView, { label }));
+  try {
+    return await task();
+  } finally {
+    instance.unmount();
+  }
+};
+const tuiMascot = async () => {
+  if (!isInteractive()) {
+    return;
+  }
+  await printFrame(
+    jsxs(Box, { paddingX: 1, children: [
+      jsx(Text, { color: MOON_LIGHT, children: LUNA_ART }),
+      jsxs(Box, { flexDirection: "column", marginLeft: 2, children: [
+        jsx(Text, { bold: true, color: ACCENT, children: LUNA_NAME }),
+        jsx(Text, { children: LUNA_SIGNOFF })
+      ] })
+    ] })
+  );
+};
+const INFO_CYAN = "#06b6d4";
+const PROSE_INDENT = " ".repeat(9);
+const tuiHeadline = async (message) => {
+  if (!isInteractive()) {
+    return;
+  }
+  await printFrame(jsx(Text, { bold: true, children: `${PROSE_INDENT}${message}` }));
+};
+const tuiInfo = async (message) => {
+  if (!isInteractive()) {
+    return;
+  }
+  await printFrame(
+    jsxs(Box, { children: [
+      jsx(Text, { color: INFO_CYAN, children: `${HEADER_INDENT}◼` }),
+      jsx(Text, { children: `  ${message}` })
+    ] })
+  );
+};
+const tuiNextSteps = async (badge, header, steps, help) => {
+  if (!isInteractive()) {
+    return;
+  }
+  await printFrame(
+    jsxs(Box, { flexDirection: "column", children: [
+      jsxs(Box, { children: [
+        jsx(Badge, { spec: badge }),
+        jsx(Text, { bold: true, children: ` ${header}` })
+      ] }),
+      jsx(Box, { flexDirection: "column", marginTop: 1, children: steps.map((step) => jsxs(Text, { children: [
+        `${PROSE_INDENT}${step.lead} `,
+        jsx(Text, { color: ACCENT, children: step.code }),
+        step.tail ?? ""
+      ] }, step.lead)) }),
+      jsx(Box, { flexDirection: "column", marginTop: 1, children: help.map((line) => jsxs(Text, { children: [
+        `${PROSE_INDENT}${line.lead} `,
+        jsx(Text, { color: ACCENT, children: line.code }),
+        line.tail ?? ""
+      ] }, line.lead)) })
+    ] })
+  );
+};
+const TASK_INDENT = " ".repeat(BADGE_COLUMN_WIDTH - 1);
+const SPINNER_FIRST = "#a855f7";
+const SPINNER_LAST = "#06b6d4";
+const SPINNER_COLORS = [SPINNER_FIRST, "#9b51f6", "#8a5cf6", "#6f86f6", "#4aa6ef", "#2bb6dd", "#12bcd0", SPINNER_LAST];
+const SPINNER_BAR_WIDTH = SPINNER_COLORS.length - 2;
+const repeatColor = (count, value) => Array.from({ length: Math.max(0, count) }, () => value);
+const SPINNER_STRIP = [
+  ...repeatColor(SPINNER_COLORS.length - 1, SPINNER_FIRST),
+  ...SPINNER_COLORS,
+  ...repeatColor(SPINNER_COLORS.length - 1, SPINNER_LAST),
+  ...SPINNER_COLORS.toReversed()
+];
+const SPINNER_FRAMES = SPINNER_STRIP.map((_, offset) => {
+  const window = SPINNER_STRIP.slice(offset, offset + SPINNER_BAR_WIDTH);
+  return [...window, ...repeatColor(SPINNER_BAR_WIDTH - window.length, SPINNER_FIRST)];
+});
+const SPINNER_LEAD = " ".repeat(Math.max(0, BADGE_COLUMN_WIDTH - SPINNER_BAR_WIDTH));
+const GradientSpinner = ({ label }) => {
+  const [index, setIndex] = useState(0);
+  useInterval(() => {
+    setIndex((previous) => (previous + 1) % SPINNER_FRAMES.length);
+  }, 90);
+  const colors = SPINNER_FRAMES[index % SPINNER_FRAMES.length] ?? [];
+  return jsxs(Text, { children: [
+    SPINNER_LEAD,
+    colors.map((color, blockIndex) => (
+      // eslint-disable-next-line react-x/no-array-index-key -- fixed-length gradient bar that never reorders.
+      jsx(Text, { color, children: "█" }, blockIndex)
+    )),
+    ` ${label}`
+  ] });
+};
+const TaskRow = ({ label, status }) => {
+  if (status === "running") {
+    return jsx(Text, { color: ACCENT, children: `${TASK_INDENT}▶ ${label}` });
+  }
+  if (status === "failed") {
+    return jsx(Text, { color: "red", children: `${TASK_INDENT}✖ ${label}` });
+  }
+  if (status === "done") {
+    return jsx(Text, { dimColor: true, children: `${TASK_INDENT}■ ${label}` });
+  }
+  return jsx(Text, { dimColor: true, children: `${TASK_INDENT}□ ${label}` });
+};
+const runTaskList = async (tasks, mark) => {
+  const results = [];
+  let failure;
+  for (const [index, task] of tasks.entries()) {
+    mark(index, "running");
+    try {
+      results.push(await task.run());
+      mark(index, "done");
+    } catch (error) {
+      mark(index, "failed");
+      failure = error;
+      break;
+    }
+  }
+  return { failure, results };
+};
+const startTasks = (tasks, setStatuses, onSettle, exit) => {
+  let active = true;
+  const mark = (index, status) => {
+    if (active) {
+      setStatuses((previous) => previous.map((value, position) => position === index ? status : value));
+    }
+  };
+  runTaskList(tasks, mark).then(({ failure, results }) => {
+    setTimeout(() => {
+      if (active) {
+        onSettle(results, failure);
+        exit();
+      }
+    }, 400);
+    return void 0;
+  }).catch(() => {
+  });
+  return () => {
+    active = false;
+  };
+};
+const TasksView = ({ end, onSettle, start, tasks }) => {
+  const { exit } = useApp();
+  const [statuses, setStatuses] = useState(() => tasks.map(() => "pending"));
+  useEffect(() => startTasks(tasks, setStatuses, onSettle, exit), [exit, onSettle, tasks]);
+  const allDone = statuses.length > 0 && statuses.every((status) => status === "done");
+  return jsxs(Box, { flexDirection: "column", children: [
+    allDone ? jsxs(Box, { children: [
+      jsx(Text, { bold: true, color: "green", children: `${HEADER_INDENT}✔` }),
+      jsx(Text, { bold: true, color: "green", children: ` ${end}` })
+    ] }) : jsx(GradientSpinner, { label: start }),
+    tasks.map((task, index) => jsx(TaskRow, { label: task.label, status: statuses[index] ?? "pending" }, task.label))
+  ] });
+};
+const tuiTasks = async (tasks, labels) => {
+  if (!isInteractive()) {
+    const results2 = [];
+    for (const task of tasks) {
+      results2.push(await task.run());
+    }
+    return results2;
+  }
+  let results = [];
+  let failure;
+  await runInkApp(
+    jsx(
+      TasksView,
+      {
+        end: labels.end,
+        onSettle: (settledResults, settledFailure) => {
+          results = settledResults;
+          failure = settledFailure;
+        },
+        start: labels.start,
+        tasks
+      }
+    )
+  );
+  if (failure !== void 0) {
+    throw toError(failure);
+  }
+  return results;
+};
+const runProgressSteps = async (steps, mark) => {
+  const values = [];
+  let failure;
+  for (const [index, step] of steps.entries()) {
+    mark(index);
+    try {
+      values.push(await step.task());
+    } catch (error) {
+      failure = error;
+      break;
+    }
+  }
+  return { failure, values };
+};
+const BadgeProgressView = ({ badge, done, onSettle, steps }) => {
+  const { exit } = useApp();
+  const [index, setIndex] = useState(0);
+  const [finished, setFinished] = useState(false);
+  useEffect(() => {
+    let active = true;
+    let timer;
+    const mark = (next) => {
+      if (active) {
+        setIndex(next);
+      }
+    };
+    runProgressSteps(steps, mark).then(({ failure, values }) => {
+      if (!active) {
+        return void 0;
+      }
+      if (failure !== void 0) {
+        onSettle({ error: failure, ok: false });
+        exit();
+        return void 0;
+      }
+      setFinished(true);
+      timer = setTimeout(() => {
+        if (active) {
+          onSettle({ ok: true, values });
+          exit();
+        }
+      }, 400);
+      return void 0;
+    }).catch(() => {
+    });
+    return () => {
+      active = false;
+      if (timer !== void 0) {
+        clearTimeout(timer);
+      }
+    };
+  }, [exit, onSettle, steps]);
+  return finished ? jsxs(Box, { children: [
+    jsx(Badge, { spec: badge }),
+    jsx(Text, { bold: true, children: ` ${done}` })
+  ] }) : jsx(GradientSpinner, { label: steps[index]?.running ?? "" });
+};
+const withTuiBadgeProgress = async (badge, steps, done) => {
+  if (!isInteractive()) {
+    const values = [];
+    for (const step of steps) {
+      values.push(await step.task());
+    }
+    return values;
+  }
+  let outcome;
+  await runInkApp(
+    jsx(
+      BadgeProgressView,
+      {
+        badge,
+        done,
+        onSettle: (settled) => {
+          outcome = settled;
+        },
+        steps
+      }
+    )
+  );
+  if (outcome === void 0) {
+    throw new PromptCancelledError();
+  }
+  if (!outcome.ok) {
+    throw toError(outcome.error);
+  }
+  return outcome.values;
+};
+
+export { tuiSelect as a, tuiConfirm as b, createTuiConfirm as c, tuiMascot as d, tuiStep as e, tuiMoonrise as f, tuiHeadline as g, tuiInfo as h, tuiNextSteps as i, tuiTasks as j, tuiMultiSelect as k, withTuiBadgeProgress as l, tuiText as t, withTuiSpinner as w };

package/dist/packem_shared/wrangler-secrets-P2_ZUR-k.mjs

@@ -0,0 +1,47 @@
+import { execFile } from 'node:child_process';
+
+const execCode = (error) => {
+  if (!error) {
+    return 0;
+  }
+  return typeof error.code === "number" ? error.code : 1;
+};
+const defaultRunner = (command, args, cwd) => new Promise((resolve) => {
+  execFile(command, [...args], { cwd }, (error, stdout, stderr) => {
+    resolve({ code: execCode(error), stderr, stdout });
+  });
+});
+const parseSecretNames = (stdout) => {
+  let parsed;
+  try {
+    parsed = JSON.parse(stdout);
+  } catch {
+    return void 0;
+  }
+  if (!Array.isArray(parsed)) {
+    return void 0;
+  }
+  const names = parsed.map((entry) => entry !== null && typeof entry === "object" ? entry.name : void 0).filter((name) => typeof name === "string" && name.length > 0);
+  return [...names].toSorted((a, b) => a.localeCompare(b));
+};
+const listRemoteSecrets = async (inputs) => {
+  const args = ["exec", "wrangler", "secret", "list", "--format", "json"];
+  if (inputs.env !== void 0) {
+    args.push("--env", inputs.env);
+  }
+  if (inputs.temporary) {
+    args.push("--temporary");
+  }
+  const runner = inputs.runner ?? defaultRunner;
+  const result = await runner("pnpm", args, inputs.cwd);
+  if (result.code !== 0) {
+    return { error: result.stderr.trim() || `wrangler secret list exited ${String(result.code)}`, names: [], ok: false };
+  }
+  const names = parseSecretNames(result.stdout);
+  if (names === void 0) {
+    return { error: "could not parse `wrangler secret list --format json` output", names: [], ok: false };
+  }
+  return { names, ok: true };
+};
+
+export { listRemoteSecrets as l };