@polterware/polter 0.0.0

package/dist/index.js

@@ -0,0 +1,2935 @@
+#!/usr/bin/env node
+
+// src/index.tsx
+import React8 from "react";
+import { render } from "ink";
+
+// src/app.tsx
+import { Box as Box14, Text as Text13, useApp } from "ink";
+
+// src/hooks/useNavigation.ts
+import { useState, useCallback } from "react";
+function useNavigation() {
+  const [state, setState] = useState({
+    screen: "main-menu",
+    params: {}
+  });
+  const navigate = useCallback((screen, params) => {
+    setState({
+      screen,
+      params: params ?? {}
+    });
+  }, []);
+  const goBack = useCallback(() => {
+    setState({ screen: "main-menu", params: {} });
+  }, []);
+  return { screen: state.screen, params: state.params, navigate, goBack };
+}
+
+// src/screens/MainMenu.tsx
+import { useEffect as useEffect2, useMemo as useMemo2, useState as useState3 } from "react";
+import { Box as Box4, Text as Text4 } from "ink";
+
+// src/components/GhostBanner.tsx
+import { Box, Text } from "ink";
+
+// src/theme.ts
+import { createRequire } from "module";
+import pc from "picocolors";
+var require2 = createRequire(import.meta.url);
+var packageJson = require2("../package.json");
+var SUPABASE_HEX = "#3ECF8E";
+var SUPABASE_FG = "\x1B[38;2;62;207;142m";
+var SUPABASE_BG = "\x1B[48;2;62;207;142m";
+var RESET_FG = "\x1B[39m";
+var RESET_BG = "\x1B[49m";
+var wrapAnsi = (open, close) => (input2) => pc.isColorSupported ? `${open}${input2}${close}` : input2;
+var supabase = wrapAnsi(SUPABASE_FG, RESET_FG);
+var supabaseBg = wrapAnsi(SUPABASE_BG, RESET_BG);
+var VERSION = packageJson.version;
+var inkColors = {
+  accent: SUPABASE_HEX,
+  accentContrast: "#081116"
+};
+var colors = {
+  primary: supabase,
+  primaryBold: (s) => pc.bold(supabase(s)),
+  accent: supabase,
+  accentBold: (s) => pc.bold(supabase(s)),
+  success: supabase,
+  successBold: (s) => pc.bold(supabase(s)),
+  error: pc.red,
+  errorBold: (s) => pc.bold(pc.red(s)),
+  warning: supabase,
+  warningBold: (s) => pc.bold(supabase(s)),
+  dim: pc.dim,
+  bold: pc.bold,
+  white: pc.white,
+  highlight: (s) => supabaseBg(pc.black(pc.bold(s)))
+};
+var ghost = {
+  art: [
+    "    \u2584\u2584\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2584\u2584",
+    "   \u2588                \u2588",
+    "  \u2588   \u2584\u2588\u2588\u2584     \u2582\u2588\u2582   \u2588",
+    "  \u2588   \u2580\u2588\u2588\u2580     \u2594\u2588\u2594   \u2588",
+    "  \u2588                  \u2588",
+    "  \u2588   \u2588\u2588 \u2588\u2588\u2588\u2588\u2588\u2588 \u2588\u2588   \u2588",
+    "  \u2588                  \u2588",
+    "  \u2588\u2584\u2588\u2588\u2580\u2580\u2588\u2588\u2584\u2584\u2584\u2584\u2588\u2588\u2580\u2580\u2588\u2588\u2584\u2588"
+  ]
+};
+
+// src/components/GhostBanner.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+function GhostBanner() {
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "row", alignItems: "flex-start", gap: 2, marginBottom: 1, children: [
+    /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: ghost.art.map((line, i) => /* @__PURE__ */ jsx(Text, { color: inkColors.accent, children: line }, i)) }),
+    /* @__PURE__ */ jsxs(
+      Box,
+      {
+        flexDirection: "column",
+        borderStyle: "single",
+        borderColor: inkColors.accent,
+        paddingX: 1,
+        children: [
+          /* @__PURE__ */ jsx(
+            Text,
+            {
+              backgroundColor: inkColors.accent,
+              color: inkColors.accentContrast,
+              bold: true,
+              children: " POLTER "
+            }
+          ),
+          /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+            "Version: ",
+            VERSION
+          ] }),
+          /* @__PURE__ */ jsx(Text, { dimColor: true, children: "The modern interactive CLI for Supabase" })
+        ]
+      }
+    )
+  ] });
+}
+
+// src/components/SelectList.tsx
+import { useEffect, useMemo, useState as useState2 } from "react";
+import { Box as Box2, Text as Text2, useInput } from "ink";
+
+// src/components/selectListSections.ts
+function isHeader(item) {
+  return item?.kind === "header";
+}
+function buildEntryKey(item, globalIndex) {
+  return item.id ?? `${item.value}-${globalIndex}`;
+}
+function findNearestHeaderLabel(items, startIndex) {
+  for (let index = startIndex; index >= 0; index -= 1) {
+    const item = items[index];
+    if (isHeader(item)) {
+      return item?.label;
+    }
+  }
+  return void 0;
+}
+function buildBoxedSectionLayout(items, start, end) {
+  const visibleEntries = items.slice(start, end).map((item, offset) => ({
+    item,
+    globalIndex: start + offset
+  }));
+  const inheritedHeader = visibleEntries.length > 0 && !isHeader(visibleEntries[0]?.item) ? findNearestHeaderLabel(items, start - 1) : void 0;
+  const sections = [];
+  let currentTitle = inheritedHeader;
+  let currentKey = currentTitle ? `derived-${start}` : void 0;
+  let currentRows = [];
+  const flush = () => {
+    if (!currentTitle && currentRows.length === 0) {
+      return;
+    }
+    if (currentRows.length === 0) {
+      sections.push({
+        type: "heading",
+        key: currentKey ?? `heading-${sections.length}`,
+        label: currentTitle ?? ""
+      });
+    } else {
+      sections.push({
+        type: "box",
+        key: currentKey ?? `box-${sections.length}`,
+        title: currentTitle ?? "",
+        rows: [...currentRows]
+      });
+    }
+    currentTitle = void 0;
+    currentKey = void 0;
+    currentRows = [];
+  };
+  for (const entry of visibleEntries) {
+    if (isHeader(entry.item)) {
+      flush();
+      currentTitle = entry.item.label;
+      currentKey = buildEntryKey(entry.item, entry.globalIndex);
+      continue;
+    }
+    if (!currentTitle) {
+      currentTitle = "";
+      currentKey = buildEntryKey(entry.item, entry.globalIndex);
+    }
+    currentRows.push(entry);
+  }
+  flush();
+  return sections.filter(
+    (section) => section.type === "box" ? section.rows.length > 0 : Boolean(section.label)
+  );
+}
+function countBoxedSectionLines(sections) {
+  return sections.reduce((lineCount, section) => {
+    if (section.type === "heading") {
+      return lineCount + 1;
+    }
+    return lineCount + section.rows.length + (section.title ? 3 : 2);
+  }, 0);
+}
+
+// src/components/SelectList.tsx
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function SelectList({
+  items,
+  onSelect,
+  onRightAction,
+  onCancel,
+  maxVisible = 16,
+  labelWidth = 34,
+  boxedSections = false
+}) {
+  const isHeader2 = (item) => item.kind === "header";
+  const isSelectable = (item) => item.selectable ?? !isHeader2(item);
+  const isPinnedRow = (item) => item.section === "pinned-runs" || item.section === "pinned-commands";
+  const selectableIndexes = useMemo(
+    () => items.reduce((acc, item, index) => {
+      if (isSelectable(item)) {
+        acc.push(index);
+      }
+      return acc;
+    }, []),
+    [items]
+  );
+  const [selectedSelectableIndex, setSelectedSelectableIndex] = useState2(0);
+  useEffect(() => {
+    if (selectableIndexes.length === 0) {
+      setSelectedSelectableIndex(0);
+      return;
+    }
+    setSelectedSelectableIndex((prev) => {
+      if (prev < 0) return 0;
+      if (prev >= selectableIndexes.length) return selectableIndexes.length - 1;
+      return prev;
+    });
+  }, [selectableIndexes]);
+  const selectedItemIndex = selectableIndexes[selectedSelectableIndex] ?? -1;
+  const selectedItem = selectedItemIndex >= 0 ? items[selectedItemIndex] : void 0;
+  useInput((input2, key) => {
+    if (selectableIndexes.length === 0) {
+      if (key.escape && onCancel) {
+        onCancel();
+      }
+      return;
+    }
+    if (key.upArrow || input2 === "k") {
+      setSelectedSelectableIndex((prev) => {
+        let next = prev - 1;
+        if (next < 0) next = selectableIndexes.length - 1;
+        return next;
+      });
+    }
+    if (key.downArrow || input2 === "j") {
+      setSelectedSelectableIndex((prev) => {
+        let next = prev + 1;
+        if (next >= selectableIndexes.length) next = 0;
+        return next;
+      });
+    }
+    if (key.return) {
+      if (selectedItem) {
+        onSelect(selectedItem.value, selectedItem);
+      }
+    }
+    if (key.rightArrow && onRightAction && selectedItem?.rightActionable) {
+      onRightAction(selectedItem);
+    }
+    if (key.escape && onCancel) {
+      onCancel();
+    }
+  });
+  const getWindowStart = () => {
+    if (items.length <= maxVisible) {
+      return 0;
+    }
+    const safeSelectedIndex = selectedItemIndex >= 0 ? selectedItemIndex : 0;
+    let start = Math.max(
+      0,
+      Math.min(
+        safeSelectedIndex - Math.floor(maxVisible / 2),
+        items.length - maxVisible
+      )
+    );
+    const firstVisible = items[start];
+    if (start > 0 && firstVisible && !isHeader2(firstVisible)) {
+      let previousHeaderIndex = -1;
+      for (let i = start - 1; i >= 0; i--) {
+        if (isHeader2(items[i])) {
+          previousHeaderIndex = i;
+          break;
+        }
+      }
+      if (previousHeaderIndex >= 0 && safeSelectedIndex - previousHeaderIndex < maxVisible) {
+        start = previousHeaderIndex;
+      }
+    }
+    return start;
+  };
+  const getWindowRange = () => {
+    const initialStart = getWindowStart();
+    const initialEnd = Math.min(initialStart + maxVisible, items.length);
+    if (!boxedSections) {
+      return [initialStart, initialEnd];
+    }
+    let start = initialStart;
+    let end = initialEnd;
+    while (start < end) {
+      const sections = buildBoxedSectionLayout(items, start, end);
+      if (countBoxedSectionLines(sections) <= maxVisible) {
+        break;
+      }
+      if (selectedItemIndex >= 0 && start === selectedItemIndex && end === selectedItemIndex + 1) {
+        break;
+      }
+      const canTrimStart = selectedItemIndex > start;
+      const canTrimEnd = selectedItemIndex < end - 1;
+      if (canTrimEnd && (!canTrimStart || end - selectedItemIndex >= selectedItemIndex - start)) {
+        end -= 1;
+        continue;
+      }
+      if (canTrimStart) {
+        start += 1;
+        continue;
+      }
+      end -= 1;
+    }
+    return [start, end];
+  };
+  const [windowStart, windowEnd] = getWindowRange();
+  const visibleItems = items.slice(windowStart, windowEnd);
+  const boxedLayout = boxedSections ? buildBoxedSectionLayout(items, windowStart, windowEnd) : [];
+  const showScrollUp = windowStart > 0;
+  const showScrollDown = windowEnd < items.length;
+  const renderSelectableRow = (item, globalIdx) => {
+    const isSelected = globalIdx === selectedItemIndex;
+    return /* @__PURE__ */ jsxs2(Box2, { gap: 1, children: [
+      /* @__PURE__ */ jsx2(Text2, { color: isSelected ? inkColors.accent : void 0, children: isSelected ? "\u276F" : " " }),
+      /* @__PURE__ */ jsx2(Box2, { width: labelWidth, children: /* @__PURE__ */ jsxs2(
+        Text2,
+        {
+          color: isSelected ? inkColors.accent : isPinnedRow(item) ? "white" : void 0,
+          bold: isSelected || isPinnedRow(item),
+          children: [
+            item.icon ? `${item.icon} ` : "",
+            item.label
+          ]
+        }
+      ) }),
+      item.hint && /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: item.hint }),
+      isSelected && item.rightActionable && /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "\u2192 pin/unpin" })
+    ] }, item.id ?? `${item.value}-${globalIdx}`);
+  };
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", children: [
+    showScrollUp && /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "  \u2191 more" }),
+    boxedSections ? boxedLayout.map((section) => {
+      if (section.type === "heading") {
+        return /* @__PURE__ */ jsx2(Box2, { children: /* @__PURE__ */ jsx2(Text2, { color: inkColors.accent, bold: true, children: section.label }) }, section.key);
+      }
+      const hasSelectedRow = section.rows.some(
+        (row) => row.globalIndex === selectedItemIndex
+      );
+      const isPinnedSection = section.rows.some(
+        (row) => isPinnedRow(row.item)
+      );
+      return /* @__PURE__ */ jsxs2(
+        Box2,
+        {
+          flexDirection: "column",
+          borderStyle: "round",
+          borderColor: inkColors.accent,
+          borderDimColor: !hasSelectedRow && !isPinnedSection,
+          paddingX: 1,
+          children: [
+            section.title && /* @__PURE__ */ jsx2(Text2, { color: inkColors.accent, bold: true, children: section.title }),
+            /* @__PURE__ */ jsx2(Box2, { flexDirection: "column", children: section.rows.map(
+              (row) => renderSelectableRow(row.item, row.globalIndex)
+            ) })
+          ]
+        },
+        section.key
+      );
+    }) : visibleItems.map((item, i) => {
+      const globalIdx = windowStart + i;
+      const selectable = isSelectable(item);
+      if (!selectable) {
+        return /* @__PURE__ */ jsx2(
+          Box2,
+          {
+            marginTop: i === 0 ? 0 : 1,
+            children: /* @__PURE__ */ jsx2(Text2, { color: inkColors.accent, bold: true, children: item.label })
+          },
+          item.id ?? `${item.value}-${globalIdx}`
+        );
+      }
+      return renderSelectableRow(item, globalIdx);
+    }),
+    showScrollDown && /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "  \u2193 more" })
+  ] });
+}
+
+// src/components/StatusBar.tsx
+import { Box as Box3, Text as Text3 } from "ink";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function StatusBar({ hint }) {
+  return /* @__PURE__ */ jsxs3(Box3, { marginTop: 1, justifyContent: "space-between", children: [
+    /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: hint || "\u2191\u2193 navigate \xB7 Enter select \xB7 Esc back" }),
+    /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+      "polter v",
+      VERSION
+    ] })
+  ] });
+}
+
+// src/data/pins.ts
+import Conf from "conf";
+var config = new Conf({
+  projectName: process.env.NODE_ENV === "test" ? "polter-test" : "polter"
+});
+var COMMAND_PINS_KEY = "pinnedCommandBasesV2";
+var RUN_PINS_KEY = "pinnedCommandRunsV1";
+var LEGACY_PINS_KEY = "pinnedCommands";
+function ensurePinsInitialized() {
+  if (!config.has(COMMAND_PINS_KEY)) {
+    config.set(COMMAND_PINS_KEY, []);
+  }
+  if (!config.has(RUN_PINS_KEY)) {
+    config.set(RUN_PINS_KEY, []);
+  }
+  if (config.has(LEGACY_PINS_KEY)) {
+    config.delete(LEGACY_PINS_KEY);
+  }
+}
+function getPinnedCommands() {
+  ensurePinsInitialized();
+  return config.get(COMMAND_PINS_KEY) || [];
+}
+function setPinnedCommands(commands) {
+  config.set(COMMAND_PINS_KEY, commands);
+}
+function togglePinnedCommand(cmd) {
+  ensurePinsInitialized();
+  const current = getPinnedCommands();
+  if (current.includes(cmd)) {
+    setPinnedCommands(current.filter((c) => c !== cmd));
+    return;
+  }
+  setPinnedCommands([cmd, ...current.filter((c) => c !== cmd)]);
+}
+function getPinnedRuns() {
+  ensurePinsInitialized();
+  return config.get(RUN_PINS_KEY) || [];
+}
+function setPinnedRuns(runs) {
+  config.set(RUN_PINS_KEY, runs);
+}
+function togglePinnedRun(runCommand2) {
+  ensurePinsInitialized();
+  const current = getPinnedRuns();
+  if (current.includes(runCommand2)) {
+    setPinnedRuns(current.filter((run) => run !== runCommand2));
+    return;
+  }
+  setPinnedRuns([runCommand2, ...current.filter((run) => run !== runCommand2)]);
+}
+function isPinnedRun(runCommand2) {
+  return getPinnedRuns().includes(runCommand2);
+}
+
+// src/data/commands.ts
+var categories = {
+  "quick-start": {
+    icon: "\u{1F680}",
+    label: "Quick Start",
+    description: "Get started with Supabase",
+    commands: [
+      {
+        value: "bootstrap",
+        label: "bootstrap",
+        hint: "Bootstrap from a starter template"
+      },
+      { value: "init", label: "init", hint: "Initialize a local project" },
+      {
+        value: "login",
+        label: "login",
+        hint: "Authenticate with access token"
+      },
+      { value: "logout", label: "logout", hint: "Remove local auth token" }
+    ]
+  },
+  "local-dev": {
+    icon: "\u{1F6E0}",
+    label: "Local Dev",
+    description: "Day-to-day local workflow",
+    commands: [
+      {
+        value: "start",
+        label: "start",
+        hint: "Start local Supabase containers"
+      },
+      { value: "stop", label: "stop", hint: "Stop local Supabase containers" },
+      { value: "status", label: "status", hint: "Show container status" },
+      { value: "db", label: "db", hint: "Manage Postgres databases" },
+      {
+        value: "migration",
+        label: "migration",
+        hint: "Manage migration scripts"
+      },
+      { value: "seed", label: "seed", hint: "Seed from config.toml" },
+      { value: "test", label: "test", hint: "Run tests on local stack" }
+    ]
+  },
+  "inspect-generate": {
+    icon: "\u{1F50D}",
+    label: "Inspect & Generate",
+    description: "Tooling and introspection",
+    commands: [
+      { value: "inspect", label: "inspect", hint: "Inspect project resources" },
+      { value: "gen", label: "gen", hint: "Run code generation tools" },
+      { value: "services", label: "services", hint: "Show service versions" },
+      { value: "link", label: "link", hint: "Link to remote project" },
+      { value: "unlink", label: "unlink", hint: "Unlink remote project" }
+    ]
+  },
+  cloud: {
+    icon: "\u2601\uFE0F",
+    label: "Cloud Management",
+    description: "Core cloud resources",
+    commands: [
+      {
+        value: "projects",
+        label: "projects",
+        hint: "Manage Supabase projects"
+      },
+      { value: "functions", label: "functions", hint: "Manage Edge Functions" },
+      { value: "secrets", label: "secrets", hint: "Manage project secrets" },
+      {
+        value: "config",
+        label: "config",
+        hint: "Manage project configuration"
+      },
+      { value: "storage", label: "storage", hint: "Manage Storage objects" }
+    ]
+  },
+  networking: {
+    icon: "\u{1F310}",
+    label: "Networking & Security",
+    description: "Network and security config",
+    commands: [
+      { value: "domains", label: "domains", hint: "Manage custom domains" },
+      {
+        value: "ssl-enforcement",
+        label: "ssl-enforcement",
+        hint: "Manage SSL config"
+      },
+      {
+        value: "network-bans",
+        label: "network-bans",
+        hint: "Manage network bans"
+      },
+      {
+        value: "network-restrictions",
+        label: "network-restrictions",
+        hint: "Manage network restrictions"
+      },
+      {
+        value: "vanity-subdomains",
+        label: "vanity-subdomains",
+        hint: "Manage vanity subdomains"
+      },
+      {
+        value: "encryption",
+        label: "encryption",
+        hint: "Manage encryption keys"
+      }
+    ]
+  },
+  "org-auth": {
+    icon: "\u{1F465}",
+    label: "Organizations & Admin",
+    description: "Team management and admin tools",
+    commands: [
+      { value: "orgs", label: "orgs", hint: "Manage organizations" },
+      { value: "sso", label: "sso", hint: "Manage Single Sign-On" },
+      { value: "branches", label: "branches", hint: "Manage preview branches" },
+      { value: "backups", label: "backups", hint: "Manage physical backups" },
+      { value: "snippets", label: "snippets", hint: "Manage SQL snippets" },
+      {
+        value: "postgres-config",
+        label: "postgres-config",
+        hint: "Manage Postgres config"
+      }
+    ]
+  },
+  utilities: {
+    icon: "\u2699\uFE0F",
+    label: "Utilities",
+    description: "Help and shell completions",
+    commands: [
+      {
+        value: "completion",
+        label: "completion",
+        hint: "Generate shell completion script"
+      },
+      { value: "help", label: "help", hint: "Help about any command" }
+    ]
+  }
+};
+
+// src/screens/mainMenuModel.ts
+var commandCatalog = Object.entries(categories).flatMap(
+  ([, category]) => category.commands.map((command) => ({
+    categoryIcon: category.icon,
+    categoryLabel: category.label,
+    value: command.value,
+    hint: command.hint
+  }))
+);
+var commandInfoByValue = new Map(
+  commandCatalog.map((entry) => [entry.value, entry])
+);
+function getCommandInfo(commandValue) {
+  return commandInfoByValue.get(commandValue);
+}
+function buildMainMenuItems({
+  pinnedCommands,
+  pinnedRuns
+}) {
+  const pinnedCommandSet = new Set(pinnedCommands);
+  const nextItems = [];
+  if (pinnedRuns.length > 0) {
+    nextItems.push({
+      id: "section-pinned-runs",
+      value: "__section_pinned_runs__",
+      label: "\u25B6 Pinned Runs",
+      kind: "header",
+      selectable: false
+    });
+    for (const runCommand2 of pinnedRuns) {
+      const baseCommand = runCommand2.split(" ").filter(Boolean)[0] ?? "";
+      const info = getCommandInfo(baseCommand);
+      const infoHint = info ? `${info.categoryIcon} ${info.categoryLabel} \xB7 exact pinned run` : "Exact pinned run";
+      nextItems.push({
+        id: `run:${runCommand2}`,
+        value: runCommand2,
+        label: runCommand2,
+        hint: infoHint,
+        icon: "\u25B6",
+        kind: "run",
+        rightActionable: true,
+        section: "pinned-runs"
+      });
+    }
+  }
+  if (pinnedCommands.length > 0) {
+    nextItems.push({
+      id: "section-pinned-commands",
+      value: "__section_pinned_commands__",
+      label: "\u{1F4CC} Pinned Commands",
+      kind: "header",
+      selectable: false
+    });
+    for (const command of pinnedCommands) {
+      const info = getCommandInfo(command);
+      const infoHint = info ? `${info.categoryIcon} ${info.categoryLabel}${info.hint ? ` \xB7 ${info.hint}` : ""}` : "Pinned command";
+      nextItems.push({
+        id: `command:${command}`,
+        value: command,
+        label: command,
+        hint: infoHint,
+        icon: "\u{1F4CC}",
+        kind: "command",
+        rightActionable: true,
+        section: "pinned-commands"
+      });
+    }
+  }
+  nextItems.push({
+    id: "section-all-commands",
+    value: "__section_all_commands__",
+    label: "\u{1F4C2} All Commands",
+    kind: "header",
+    selectable: false
+  });
+  for (const [categoryKey, category] of Object.entries(categories)) {
+    nextItems.push({
+      id: `category-${categoryKey}`,
+      value: `__category_${categoryKey}__`,
+      label: `${category.icon}  ${category.label}`,
+      kind: "header",
+      selectable: false
+    });
+    for (const command of category.commands) {
+      const pinHint = pinnedCommandSet.has(command.value) ? "pinned" : void 0;
+      nextItems.push({
+        id: `cmd-${categoryKey}-${command.value}`,
+        value: command.value,
+        label: command.label,
+        hint: [command.hint, pinHint].filter(Boolean).join(" \xB7 "),
+        kind: "command",
+        rightActionable: true,
+        section: categoryKey,
+        groupLabel: category.label
+      });
+    }
+  }
+  nextItems.push({
+    id: "section-actions",
+    value: "__section_actions__",
+    label: "\u26A1 Actions",
+    kind: "header",
+    selectable: false
+  });
+  nextItems.push({
+    id: "action-custom",
+    value: "__action_custom__",
+    label: "Custom Command",
+    hint: "Free-form args or check version",
+    icon: "\u270F\uFE0F",
+    kind: "action"
+  });
+  nextItems.push({
+    id: "action-update",
+    value: "__action_update__",
+    label: "Update Polter",
+    hint: "Update the current repo install or the global install",
+    icon: "\u2B06\uFE0F",
+    kind: "action"
+  });
+  nextItems.push({
+    id: "action-exit",
+    value: "__action_exit__",
+    label: "Exit",
+    icon: "\u{1F6AA}",
+    kind: "action"
+  });
+  return nextItems;
+}
+
+// src/screens/MainMenu.tsx
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+function MainMenu({
+  onNavigate,
+  onExit
+}) {
+  const [pinnedCommands, setPinnedCommands2] = useState3(
+    () => getPinnedCommands()
+  );
+  const [pinnedRuns, setPinnedRuns2] = useState3(
+    () => getPinnedRuns()
+  );
+  const [pinFeedback, setPinFeedback] = useState3();
+  useEffect2(() => {
+    if (!pinFeedback) return;
+    const timeout = setTimeout(() => setPinFeedback(void 0), 1400);
+    return () => clearTimeout(timeout);
+  }, [pinFeedback]);
+  const items = useMemo2(
+    () => buildMainMenuItems({
+      pinnedCommands,
+      pinnedRuns
+    }),
+    [pinnedCommands, pinnedRuns]
+  );
+  const pinnedCommandSet = useMemo2(
+    () => new Set(pinnedCommands),
+    [pinnedCommands]
+  );
+  const pinnedRunSet = useMemo2(() => new Set(pinnedRuns), [pinnedRuns]);
+  const refreshPins = () => {
+    setPinnedCommands2(getPinnedCommands());
+    setPinnedRuns2(getPinnedRuns());
+  };
+  const handleSelect = (value, item) => {
+    if (!item) return;
+    if (item.kind === "command") {
+      onNavigate("command-args", { command: value });
+      return;
+    }
+    if (item.kind === "run") {
+      const args = value.split(" ").filter(Boolean);
+      if (args.length > 0) {
+        onNavigate("confirm-execute", { args });
+      }
+      return;
+    }
+    if (value === "__action_custom__") {
+      onNavigate("custom-command");
+      return;
+    }
+    if (value === "__action_update__") {
+      onNavigate("self-update");
+      return;
+    }
+    if (value === "__action_exit__") {
+      onExit();
+    }
+  };
+  const handleRightAction = (item) => {
+    if (item.kind === "command") {
+      const command = item.value;
+      const wasPinned = pinnedCommandSet.has(command);
+      togglePinnedCommand(command);
+      refreshPins();
+      setPinFeedback(
+        wasPinned ? `Unpinned "${command}"` : `Pinned "${command}"`
+      );
+      return;
+    }
+    if (item.kind === "run") {
+      const runCommand2 = item.value;
+      const wasPinned = pinnedRunSet.has(runCommand2);
+      togglePinnedRun(runCommand2);
+      refreshPins();
+      setPinFeedback(
+        wasPinned ? `Unpinned exact run "${runCommand2}"` : `Pinned exact run "${runCommand2}"`
+      );
+    }
+  };
+  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx4(GhostBanner, {}),
+    /* @__PURE__ */ jsx4(Box4, { marginBottom: 1, children: /* @__PURE__ */ jsx4(Text4, { bold: true, children: "Choose a command, then press Enter to continue." }) }),
+    pinFeedback && /* @__PURE__ */ jsx4(Box4, { marginBottom: 1, children: /* @__PURE__ */ jsxs4(Text4, { color: inkColors.accent, children: [
+      "\u2713 ",
+      pinFeedback
+    ] }) }),
+    /* @__PURE__ */ jsx4(
+      SelectList,
+      {
+        items,
+        onSelect: handleSelect,
+        onRightAction: handleRightAction,
+        boxedSections: true
+      }
+    ),
+    /* @__PURE__ */ jsx4(StatusBar, { hint: "\u2191\u2193 navigate \xB7 Enter select \xB7 \u2192 pin/unpin \xB7 Esc back" })
+  ] });
+}
+
+// src/screens/CommandArgs.tsx
+import { useEffect as useEffect3, useMemo as useMemo3, useState as useState5 } from "react";
+import { Box as Box6, Text as Text6 } from "ink";
+
+// src/components/TextPrompt.tsx
+import { useState as useState4 } from "react";
+import { Box as Box5, Text as Text5, useInput as useInput2 } from "ink";
+import TextInputComponent from "ink-text-input";
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+function TextPrompt({
+  label,
+  placeholder,
+  onSubmit,
+  onCancel,
+  validate
+}) {
+  const [value, setValue] = useState4("");
+  const [error, setError] = useState4();
+  useInput2((_input, key) => {
+    if (key.escape && onCancel) {
+      onCancel();
+    }
+  });
+  const handleSubmit = (val) => {
+    if (validate) {
+      const err = validate(val);
+      if (err) {
+        setError(err);
+        return;
+      }
+    }
+    setError(void 0);
+    onSubmit(val);
+  };
+  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs5(Box5, { gap: 1, children: [
+      /* @__PURE__ */ jsx5(Text5, { color: inkColors.accent, bold: true, children: "?" }),
+      /* @__PURE__ */ jsx5(Text5, { children: label })
+    ] }),
+    /* @__PURE__ */ jsxs5(Box5, { gap: 1, marginLeft: 2, children: [
+      /* @__PURE__ */ jsx5(Text5, { color: inkColors.accent, children: "\u276F" }),
+      /* @__PURE__ */ jsx5(
+        TextInputComponent,
+        {
+          value,
+          onChange: (val) => {
+            setValue(val);
+            setError(void 0);
+          },
+          onSubmit: handleSubmit,
+          placeholder
+        }
+      )
+    ] }),
+    error && /* @__PURE__ */ jsx5(Box5, { marginLeft: 2, children: /* @__PURE__ */ jsxs5(Text5, { color: "red", children: [
+      "\u2717 ",
+      error
+    ] }) })
+  ] });
+}
+
+// src/data/suggestedArgs.ts
+var suggestedArgsByCommand = {
+  db: [
+    { value: "pull", label: "pull", hint: "Pull schema from remote", args: ["pull"] },
+    { value: "push", label: "push", hint: "Push local migrations", args: ["push"] },
+    { value: "reset", label: "reset", hint: "Reset local database", args: ["reset"] },
+    { value: "dump", label: "dump", hint: "Dump schema/data", args: ["dump"] },
+    { value: "diff", label: "diff", hint: "Show migration diff", args: ["diff"] },
+    { value: "lint", label: "lint", hint: "Lint SQL migrations", args: ["lint"] }
+  ],
+  migration: [
+    { value: "new", label: "new <name>", hint: "Create migration file", args: ["new"] },
+    { value: "up", label: "up", hint: "Apply pending migrations", args: ["up"] },
+    { value: "down", label: "down", hint: "Rollback last migration", args: ["down"] },
+    { value: "list", label: "list", hint: "List local migrations", args: ["list"] },
+    { value: "repair", label: "repair", hint: "Repair migration history", args: ["repair"] },
+    { value: "fetch", label: "fetch", hint: "Fetch migration history", args: ["fetch"] }
+  ],
+  projects: [
+    { value: "list", label: "list", hint: "List projects", args: ["list"] },
+    { value: "create", label: "create", hint: "Create project", args: ["create"] },
+    { value: "delete", label: "delete", hint: "Delete project", args: ["delete"] }
+  ],
+  functions: [
+    { value: "list", label: "list", hint: "List functions", args: ["list"] },
+    { value: "new", label: "new <name>", hint: "Create a function", args: ["new"] },
+    { value: "serve", label: "serve", hint: "Serve functions locally", args: ["serve"] },
+    { value: "deploy", label: "deploy <name>", hint: "Deploy function", args: ["deploy"] },
+    { value: "delete", label: "delete <name>", hint: "Delete function", args: ["delete"] }
+  ],
+  storage: [
+    { value: "ls", label: "ls", hint: "List storage objects", args: ["ls"] },
+    { value: "cp", label: "cp", hint: "Copy storage object", args: ["cp"] },
+    { value: "mv", label: "mv", hint: "Move storage object", args: ["mv"] },
+    { value: "rm", label: "rm", hint: "Remove storage object", args: ["rm"] }
+  ],
+  seed: [
+    { value: "run", label: "run", hint: "Run configured seed file", args: ["run"] }
+  ],
+  orgs: [
+    { value: "list", label: "list", hint: "List organizations", args: ["list"] },
+    { value: "create", label: "create", hint: "Create organization", args: ["create"] }
+  ],
+  snippets: [
+    { value: "list", label: "list", hint: "List SQL snippets", args: ["list"] },
+    { value: "create", label: "create", hint: "Create SQL snippet", args: ["create"] },
+    { value: "delete", label: "delete", hint: "Delete SQL snippet", args: ["delete"] }
+  ],
+  backups: [
+    { value: "list", label: "list", hint: "List backups", args: ["list"] },
+    { value: "download", label: "download", hint: "Download backup", args: ["download"] }
+  ]
+};
+function getSuggestedArgOptions(command) {
+  return suggestedArgsByCommand[command] ?? [];
+}
+
+// src/screens/commandArgsModel.ts
+function buildRunCommand(command, extraArgs) {
+  return [command, ...extraArgs].join(" ");
+}
+function getRunCommandFromArgsSelection(command, value, suggestions) {
+  if (value === "__run_base__") {
+    return command;
+  }
+  if (!value.startsWith("suggest:")) {
+    return void 0;
+  }
+  const optionKey = value.replace("suggest:", "");
+  const option = suggestions.find((entry) => entry.value === optionKey);
+  if (!option) {
+    return void 0;
+  }
+  return buildRunCommand(command, option.args);
+}
+function buildCommandArgItems({
+  command,
+  suggestions,
+  pinnedRuns
+}) {
+  const pinnedRunSet = new Set(pinnedRuns);
+  const baseRunCommand = buildRunCommand(command, []);
+  return [
+    {
+      value: "__suggested_header__",
+      label: `Suggested args for ${command}`,
+      kind: "header",
+      selectable: false
+    },
+    ...suggestions.map((option) => {
+      const runCommand2 = buildRunCommand(command, option.args);
+      const pinHint = pinnedRunSet.has(runCommand2) ? "pinned run" : void 0;
+      return {
+        value: `suggest:${option.value}`,
+        label: option.label,
+        hint: [option.hint, pinHint].filter(Boolean).join(" \xB7 "),
+        kind: "command",
+        rightActionable: true
+      };
+    }),
+    {
+      value: "__actions_header__",
+      label: "\u26A1 Actions",
+      kind: "header",
+      selectable: false
+    },
+    {
+      value: "__run_base__",
+      label: "Run without additional args",
+      hint: [
+        `supabase ${command}`,
+        pinnedRunSet.has(baseRunCommand) ? "pinned run" : void 0
+      ].filter(Boolean).join(" \xB7 "),
+      kind: "action",
+      rightActionable: true
+    },
+    {
+      value: "__custom__",
+      label: "Custom args...",
+      hint: "Type any arguments manually",
+      kind: "action"
+    },
+    {
+      value: "__back__",
+      label: "\u2190 Back to menu",
+      kind: "action"
+    }
+  ];
+}
+
+// src/screens/CommandArgs.tsx
+import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+function CommandArgs({
+  command,
+  onNavigate,
+  onBack
+}) {
+  const suggestions = useMemo3(() => getSuggestedArgOptions(command), [command]);
+  const [pinnedRuns, setPinnedRuns2] = useState5(() => getPinnedRuns());
+  const [pinFeedback, setPinFeedback] = useState5();
+  const [phase, setPhase] = useState5(
+    suggestions.length > 0 ? "select" : "custom"
+  );
+  useEffect3(() => {
+    setPhase(suggestions.length > 0 ? "select" : "custom");
+  }, [command, suggestions.length]);
+  useEffect3(() => {
+    if (!pinFeedback) return;
+    const timeout = setTimeout(() => setPinFeedback(void 0), 1400);
+    return () => clearTimeout(timeout);
+  }, [pinFeedback]);
+  const navigateWithExtraArgs = (extraArgs) => {
+    onNavigate("flag-selection", {
+      args: [command, ...extraArgs],
+      command
+    });
+  };
+  if (!command) {
+    return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx6(Box6, { marginBottom: 1, children: /* @__PURE__ */ jsx6(Text6, { color: "red", children: "Command not provided." }) }),
+      /* @__PURE__ */ jsx6(
+        SelectList,
+        {
+          items: [{ value: "__back__", label: "\u2190 Back to menu" }],
+          onSelect: onBack,
+          onCancel: onBack
+        }
+      )
+    ] });
+  }
+  if (phase === "custom") {
+    return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs6(Box6, { marginBottom: 1, gap: 1, children: [
+        /* @__PURE__ */ jsx6(Text6, { color: inkColors.accent, bold: true, children: "Command" }),
+        /* @__PURE__ */ jsx6(Text6, { children: command })
+      ] }),
+      /* @__PURE__ */ jsx6(
+        TextPrompt,
+        {
+          label: `Additional args for supabase ${command}?`,
+          placeholder: "e.g. list, pull, push (Enter to skip)",
+          onSubmit: (extra) => {
+            const extraArgs = extra.trim().split(" ").filter(Boolean);
+            navigateWithExtraArgs(extraArgs);
+          },
+          onCancel: () => {
+            if (suggestions.length > 0) {
+              setPhase("select");
+              return;
+            }
+            onBack();
+          }
+        }
+      ),
+      /* @__PURE__ */ jsx6(StatusBar, { hint: "Type args \xB7 Enter to continue \xB7 Esc to go back" })
+    ] });
+  }
+  const items = useMemo3(
+    () => buildCommandArgItems({
+      command,
+      suggestions,
+      pinnedRuns
+    }),
+    [command, pinnedRuns, suggestions]
+  );
+  return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs6(Box6, { marginBottom: 1, gap: 1, children: [
+      /* @__PURE__ */ jsx6(Text6, { color: inkColors.accent, bold: true, children: "Command" }),
+      /* @__PURE__ */ jsx6(Text6, { children: command })
+    ] }),
+    pinFeedback && /* @__PURE__ */ jsx6(Box6, { marginBottom: 1, children: /* @__PURE__ */ jsxs6(Text6, { color: inkColors.accent, children: [
+      "\u2713 ",
+      pinFeedback
+    ] }) }),
+    /* @__PURE__ */ jsx6(
+      SelectList,
+      {
+        items,
+        onSelect: (value) => {
+          if (value === "__back__") {
+            onBack();
+            return;
+          }
+          if (value === "__custom__") {
+            setPhase("custom");
+            return;
+          }
+          if (value === "__run_base__") {
+            navigateWithExtraArgs([]);
+            return;
+          }
+          if (value.startsWith("suggest:")) {
+            const runCommand2 = getRunCommandFromArgsSelection(
+              command,
+              value,
+              suggestions
+            );
+            if (runCommand2) {
+              navigateWithExtraArgs(
+                runCommand2.split(" ").slice(1).filter(Boolean)
+              );
+            }
+            return;
+          }
+        },
+        onRightAction: (item) => {
+          const runCommand2 = getRunCommandFromArgsSelection(
+            command,
+            item.value,
+            suggestions
+          );
+          if (!runCommand2) {
+            return;
+          }
+          const wasPinned = pinnedRuns.includes(runCommand2);
+          togglePinnedRun(runCommand2);
+          setPinnedRuns2(getPinnedRuns());
+          setPinFeedback(
+            wasPinned ? `Unpinned exact run "${runCommand2}"` : `Pinned exact run "${runCommand2}"`
+          );
+        },
+        onCancel: onBack,
+        boxedSections: true
+      }
+    ),
+    /* @__PURE__ */ jsx6(StatusBar, { hint: "\u2191\u2193 navigate \xB7 Enter select \xB7 \u2192 pin run \xB7 Esc back" })
+  ] });
+}
+
+// src/screens/CustomCommand.tsx
+import { Box as Box7 } from "ink";
+import { jsx as jsx7, jsxs as jsxs7 } from "react/jsx-runtime";
+function CustomCommand({
+  onNavigate,
+  onBack
+}) {
+  return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx7(
+      TextPrompt,
+      {
+        label: "Enter your Supabase command/flags:",
+        placeholder: "e.g. -v, status -o json, db pull",
+        validate: (val) => {
+          if (!val || !val.trim()) return "Please enter a command";
+          return void 0;
+        },
+        onSubmit: (value) => {
+          const args = value.split(" ").filter(Boolean);
+          onNavigate("flag-selection", { args });
+        },
+        onCancel: onBack
+      }
+    ),
+    /* @__PURE__ */ jsx7(StatusBar, { hint: "Type a command \xB7 Enter to continue \xB7 Esc to go back" })
+  ] });
+}
+
+// src/screens/FlagSelection.tsx
+import { Box as Box9 } from "ink";
+
+// src/components/FlagToggle.tsx
+import { useState as useState6 } from "react";
+import { Box as Box8, Text as Text7, useInput as useInput3 } from "ink";
+import { jsx as jsx8, jsxs as jsxs8 } from "react/jsx-runtime";
+function FlagToggle({
+  flags,
+  onSubmit,
+  onCancel
+}) {
+  const [cursor, setCursor] = useState6(0);
+  const [selected, setSelected] = useState6(/* @__PURE__ */ new Set());
+  useInput3((input2, key) => {
+    if (key.upArrow || input2 === "k") {
+      setCursor((prev) => prev > 0 ? prev - 1 : flags.length - 1);
+    }
+    if (key.downArrow || input2 === "j") {
+      setCursor((prev) => prev < flags.length - 1 ? prev + 1 : 0);
+    }
+    if (input2 === " ") {
+      setSelected((prev) => {
+        const next = new Set(prev);
+        const flag = flags[cursor];
+        if (next.has(flag.value)) {
+          next.delete(flag.value);
+        } else {
+          next.add(flag.value);
+        }
+        return next;
+      });
+    }
+    if (key.return) {
+      onSubmit(Array.from(selected));
+    }
+    if (key.escape && onCancel) {
+      onCancel();
+    }
+  });
+  return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs8(Box8, { marginBottom: 1, children: [
+      /* @__PURE__ */ jsx8(Text7, { bold: true, color: inkColors.accent, children: "\u2691 Global Flags" }),
+      /* @__PURE__ */ jsx8(Text7, { dimColor: true, children: " (Space to toggle, Enter to confirm)" })
+    ] }),
+    flags.map((flag, i) => {
+      const isActive = cursor === i;
+      const isChecked = selected.has(flag.value);
+      return /* @__PURE__ */ jsxs8(Box8, { gap: 1, children: [
+        /* @__PURE__ */ jsx8(Text7, { color: isActive ? inkColors.accent : void 0, children: isActive ? "\u276F" : " " }),
+        /* @__PURE__ */ jsx8(
+          Text7,
+          {
+            color: isChecked || isActive ? inkColors.accent : void 0,
+            bold: isChecked,
+            children: isChecked ? "\u25C9" : "\u25CB"
+          }
+        ),
+        /* @__PURE__ */ jsx8(
+          Text7,
+          {
+            color: isActive ? inkColors.accent : void 0,
+            bold: isActive,
+            children: flag.label
+          }
+        ),
+        flag.hint && /* @__PURE__ */ jsx8(Text7, { dimColor: true, children: flag.hint })
+      ] }, flag.value);
+    }),
+    /* @__PURE__ */ jsx8(Box8, { marginTop: 1, children: /* @__PURE__ */ jsx8(Text7, { dimColor: true, children: selected.size > 0 ? `${selected.size} flag${selected.size > 1 ? "s" : ""} selected` : "No flags selected (Enter to skip)" }) })
+  ] });
+}
+
+// src/data/flags.ts
+var globalFlags = [
+  { value: "--debug", label: "--debug", hint: "Output debug logs to stderr" },
+  { value: "--yes", label: "--yes", hint: "Answer yes to all prompts" },
+  {
+    value: "--create-ticket",
+    label: "--create-ticket",
+    hint: "Create support ticket on error"
+  },
+  {
+    value: "--experimental",
+    label: "--experimental",
+    hint: "Enable experimental features"
+  }
+];
+
+// src/screens/FlagSelection.tsx
+import { jsx as jsx9, jsxs as jsxs9 } from "react/jsx-runtime";
+function FlagSelection({
+  args,
+  onNavigate,
+  onBack
+}) {
+  return /* @__PURE__ */ jsxs9(Box9, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx9(
+      FlagToggle,
+      {
+        flags: globalFlags,
+        onSubmit: (selectedFlags) => {
+          const finalArgs = selectedFlags.length > 0 ? [...args, ...selectedFlags] : args;
+          onNavigate("confirm-execute", { args: finalArgs });
+        },
+        onCancel: onBack
+      }
+    ),
+    /* @__PURE__ */ jsx9(StatusBar, { hint: "Space toggle \xB7 Enter confirm \xB7 Esc back" })
+  ] });
+}
+
+// src/screens/CommandExecution.tsx
+import { useState as useState8, useEffect as useEffect4 } from "react";
+import { Box as Box12, Text as Text11 } from "ink";
+
+// src/components/Spinner.tsx
+import { Text as Text8 } from "ink";
+import InkSpinner from "ink-spinner";
+import { jsx as jsx10, jsxs as jsxs10 } from "react/jsx-runtime";
+function Spinner({
+  label = "Running...",
+  color = inkColors.accent
+}) {
+  return /* @__PURE__ */ jsxs10(Text8, { children: [
+    /* @__PURE__ */ jsx10(Text8, { color, children: /* @__PURE__ */ jsx10(InkSpinner, { type: "dots" }) }),
+    " ",
+    /* @__PURE__ */ jsx10(Text8, { children: label })
+  ] });
+}
+
+// src/components/ConfirmPrompt.tsx
+import { Box as Box10, Text as Text9, useInput as useInput4 } from "ink";
+import { jsx as jsx11, jsxs as jsxs11 } from "react/jsx-runtime";
+function ConfirmPrompt({
+  message,
+  defaultValue = true,
+  onConfirm
+}) {
+  useInput4((input2) => {
+    if (input2 === "y" || input2 === "Y") {
+      onConfirm(true);
+    } else if (input2 === "n" || input2 === "N") {
+      onConfirm(false);
+    } else if (input2 === "\r") {
+      onConfirm(defaultValue);
+    }
+  });
+  return /* @__PURE__ */ jsxs11(Box10, { gap: 1, children: [
+    /* @__PURE__ */ jsx11(Text9, { color: inkColors.accent, bold: true, children: "?" }),
+    /* @__PURE__ */ jsx11(Text9, { children: message }),
+    /* @__PURE__ */ jsx11(Text9, { dimColor: true, children: defaultValue ? "(Y/n)" : "(y/N)" })
+  ] });
+}
+
+// src/components/Divider.tsx
+import { Text as Text10 } from "ink";
+import { jsx as jsx12, jsxs as jsxs12 } from "react/jsx-runtime";
+function Divider({
+  label,
+  width = 50
+}) {
+  if (label) {
+    const labelLen = label.length + 2;
+    const sideLen = Math.max(2, Math.floor((width - labelLen) / 2));
+    const left = "\u2500".repeat(sideLen);
+    const right = "\u2500".repeat(sideLen);
+    return /* @__PURE__ */ jsxs12(Text10, { dimColor: true, children: [
+      left,
+      " ",
+      label,
+      " ",
+      right
+    ] });
+  }
+  return /* @__PURE__ */ jsx12(Text10, { dimColor: true, children: "\u2500".repeat(width) });
+}
+
+// src/hooks/useCommand.ts
+import { useState as useState7, useCallback as useCallback2 } from "react";
+
+// src/lib/runner.ts
+import { spawn } from "child_process";
+import { existsSync } from "fs";
+import { delimiter, dirname, join, resolve } from "path";
+function getSupabaseBinaryCandidates() {
+  if (process.platform === "win32") {
+    return ["supabase.cmd", "supabase.exe", "supabase"];
+  }
+  return ["supabase"];
+}
+function hasLocalSupabaseBinary(binDir) {
+  return getSupabaseBinaryCandidates().some(
+    (candidate) => existsSync(join(binDir, candidate))
+  );
+}
+function getPathEnvKey(env) {
+  return Object.keys(env).find((key) => key.toLowerCase() === "path") ?? "PATH";
+}
+function findLocalSupabaseBinDir(startDir = process.cwd()) {
+  let currentDir = resolve(startDir);
+  while (true) {
+    const binDir = join(currentDir, "node_modules", ".bin");
+    if (hasLocalSupabaseBinary(binDir)) {
+      return binDir;
+    }
+    const parentDir = dirname(currentDir);
+    if (parentDir === currentDir) {
+      return void 0;
+    }
+    currentDir = parentDir;
+  }
+}
+function resolveSupabaseCommand(startDir = process.cwd(), env = process.env) {
+  const localBinDir = findLocalSupabaseBinDir(startDir);
+  if (!localBinDir) {
+    return {
+      command: "supabase",
+      env: { ...env },
+      source: "path"
+    };
+  }
+  const pathKey = getPathEnvKey(env);
+  const currentPath = env[pathKey];
+  return {
+    command: "supabase",
+    env: {
+      ...env,
+      [pathKey]: currentPath ? `${localBinDir}${delimiter}${currentPath}` : localBinDir
+    },
+    source: "repository",
+    localBinDir
+  };
+}
+async function runCommand(execution, args, cwd = process.cwd()) {
+  return new Promise((resolve4) => {
+    let stdout = "";
+    let stderr = "";
+    const resolvedExecution = typeof execution === "string" ? { command: execution } : execution;
+    const child = spawn(resolvedExecution.command, args, {
+      cwd,
+      env: resolvedExecution.env,
+      shell: true,
+      stdio: ["inherit", "pipe", "pipe"]
+    });
+    child.stdout?.on("data", (data) => {
+      const text = data.toString();
+      stdout += text;
+      process.stdout.write(text);
+    });
+    child.stderr?.on("data", (data) => {
+      const text = data.toString();
+      stderr += text;
+      process.stderr.write(text);
+    });
+    child.on("error", (err) => {
+      resolve4({
+        exitCode: null,
+        signal: null,
+        stdout,
+        stderr,
+        spawnError: err.message
+      });
+    });
+    child.on("exit", (code, signal) => {
+      resolve4({ exitCode: code, signal, stdout, stderr });
+    });
+  });
+}
+async function runSupabaseCommand(args, cwd = process.cwd()) {
+  return runCommand(resolveSupabaseCommand(cwd), args, cwd);
+}
+
+// src/hooks/useCommand.ts
+function useCommand(execution = "supabase", cwd = process.cwd()) {
+  const [status, setStatus] = useState7("idle");
+  const [result, setResult] = useState7(null);
+  const run = useCallback2(async (args) => {
+    setStatus("running");
+    setResult(null);
+    const res = execution === "supabase" ? await runSupabaseCommand(args, cwd) : await runCommand(execution, args, cwd);
+    setResult(res);
+    if (res.spawnError || res.exitCode !== null && res.exitCode !== 0) {
+      setStatus("error");
+    } else {
+      setStatus("success");
+    }
+    return res;
+  }, [cwd, execution]);
+  const reset = useCallback2(() => {
+    setStatus("idle");
+    setResult(null);
+  }, []);
+  return { status, result, run, reset };
+}
+
+// src/lib/clipboard.ts
+import { spawn as spawn2, exec } from "child_process";
+async function openInBrowser(url) {
+  return new Promise((resolve4) => {
+    const cmd = process.platform === "darwin" ? `open "${url}"` : process.platform === "win32" ? `start "${url}"` : `xdg-open "${url}"`;
+    exec(cmd, () => resolve4());
+  });
+}
+async function copyToClipboard(text) {
+  return new Promise((resolve4) => {
+    const cmd = process.platform === "darwin" ? "pbcopy" : process.platform === "win32" ? "clip" : "xclip -selection clipboard";
+    const child = spawn2(cmd, [], { shell: true });
+    child.stdin?.write(text);
+    child.stdin?.end();
+    child.on("exit", () => resolve4());
+    child.on("error", () => resolve4());
+  });
+}
+
+// src/screens/CommandExecution.tsx
+import { jsx as jsx13, jsxs as jsxs13 } from "react/jsx-runtime";
+function CommandExecution({
+  args: initialArgs,
+  onBack,
+  onExit
+}) {
+  const [phase, setPhase] = useState8("confirm");
+  const [currentArgs, setCurrentArgs] = useState8(initialArgs);
+  const [pinMessage, setPinMessage] = useState8();
+  const { status, result, run, reset } = useCommand();
+  const cmdDisplay = `supabase ${currentArgs.join(" ")}`;
+  const runCommand2 = currentArgs.join(" ");
+  useEffect4(() => {
+    if (phase === "running" && status === "idle") {
+      run(currentArgs);
+    }
+  }, [phase, status, run, currentArgs]);
+  useEffect4(() => {
+    if (phase === "running" && status === "success") {
+      if (isPinnedRun(runCommand2)) {
+        setPhase("success");
+      } else {
+        setPhase("success-pin-offer");
+      }
+    }
+    if (phase === "running" && status === "error") {
+      setPhase("error-menu");
+    }
+  }, [phase, runCommand2, status]);
+  if (phase === "confirm") {
+    return /* @__PURE__ */ jsx13(Box12, { flexDirection: "column", children: /* @__PURE__ */ jsx13(
+      ConfirmPrompt,
+      {
+        message: `Execute ${cmdDisplay}?`,
+        defaultValue: true,
+        onConfirm: (confirmed) => {
+          if (confirmed) {
+            setPhase("running");
+          } else {
+            onBack();
+          }
+        }
+      }
+    ) });
+  }
+  if (phase === "running") {
+    return /* @__PURE__ */ jsxs13(Box12, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx13(Divider, {}),
+      /* @__PURE__ */ jsxs13(Box12, { marginY: 1, gap: 1, children: [
+        /* @__PURE__ */ jsx13(Text11, { color: inkColors.accent, bold: true, children: "\u25B6" }),
+        /* @__PURE__ */ jsx13(Text11, { dimColor: true, children: "Running:" }),
+        /* @__PURE__ */ jsx13(Text11, { children: cmdDisplay })
+      ] }),
+      /* @__PURE__ */ jsx13(Divider, {}),
+      /* @__PURE__ */ jsx13(Box12, { marginTop: 1, children: /* @__PURE__ */ jsx13(Spinner, { label: `Executing ${cmdDisplay}...` }) })
+    ] });
+  }
+  if (phase === "success-pin-offer") {
+    return /* @__PURE__ */ jsxs13(Box12, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx13(Divider, {}),
+      /* @__PURE__ */ jsxs13(Box12, { marginY: 1, gap: 1, children: [
+        /* @__PURE__ */ jsx13(Text11, { color: inkColors.accent, bold: true, children: "\u2713" }),
+        /* @__PURE__ */ jsx13(Text11, { color: inkColors.accent, bold: true, children: "Command completed successfully!" })
+      ] }),
+      /* @__PURE__ */ jsx13(
+        ConfirmPrompt,
+        {
+          message: "Pin this exact command?",
+          defaultValue: false,
+          onConfirm: (shouldPin) => {
+            if (shouldPin && !isPinnedRun(runCommand2)) {
+              togglePinnedRun(runCommand2);
+              setPinMessage("Exact command pinned to Pinned Runs.");
+            }
+            setPhase("success");
+          }
+        }
+      )
+    ] });
+  }
+  if (phase === "success") {
+    return /* @__PURE__ */ jsxs13(Box12, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx13(Divider, {}),
+      /* @__PURE__ */ jsxs13(Box12, { marginY: 1, gap: 1, children: [
+        /* @__PURE__ */ jsx13(Text11, { color: inkColors.accent, bold: true, children: "\u2713" }),
+        /* @__PURE__ */ jsx13(Text11, { color: inkColors.accent, bold: true, children: "Command completed successfully!" })
+      ] }),
+      pinMessage && /* @__PURE__ */ jsx13(Box12, { marginBottom: 1, children: /* @__PURE__ */ jsx13(Text11, { color: inkColors.accent, children: pinMessage }) }),
+      /* @__PURE__ */ jsx13(
+        SelectList,
+        {
+          items: [{ value: "__back__", label: "\u2190 Back to menu" }],
+          onSelect: onBack,
+          onCancel: onBack
+        }
+      )
+    ] });
+  }
+  const hasDebug = currentArgs.includes("--debug");
+  const errorItems = [];
+  if (!result?.spawnError) {
+    errorItems.push({ value: "retry", label: "\u{1F504} Retry the same command" });
+    if (!hasDebug) {
+      errorItems.push({
+        value: "retry-debug",
+        label: "\u{1F41B} Retry with --debug",
+        hint: "Append --debug for verbose logs"
+      });
+    }
+  }
+  errorItems.push(
+    {
+      value: "docs",
+      label: "\u{1F4D6} Open Supabase CLI docs",
+      hint: "Opens in browser"
+    },
+    {
+      value: "copy",
+      label: "\u{1F4CB} Copy command to clipboard"
+    },
+    { value: "menu", label: "\u2190 Return to main menu" },
+    { value: "exit", label: "\u{1F6AA} Exit Polter" }
+  );
+  return /* @__PURE__ */ jsxs13(Box12, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx13(Divider, {}),
+    result?.spawnError ? /* @__PURE__ */ jsxs13(Box12, { flexDirection: "column", marginY: 1, children: [
+      /* @__PURE__ */ jsxs13(Box12, { gap: 1, children: [
+        /* @__PURE__ */ jsx13(Text11, { color: "red", bold: true, children: "\u2717" }),
+        /* @__PURE__ */ jsx13(Text11, { color: "red", bold: true, children: "Failed to start command" })
+      ] }),
+      /* @__PURE__ */ jsxs13(Box12, { marginLeft: 2, marginTop: 1, children: [
+        /* @__PURE__ */ jsx13(Text11, { dimColor: true, children: "Error: " }),
+        /* @__PURE__ */ jsx13(Text11, { color: "red", children: result.spawnError })
+      ] }),
+      (result.spawnError.includes("ENOENT") || result.spawnError.includes("not found")) && /* @__PURE__ */ jsxs13(Box12, { flexDirection: "column", marginLeft: 2, marginTop: 1, children: [
+        /* @__PURE__ */ jsx13(Text11, { color: inkColors.accent, bold: true, children: "\u{1F4A1} Supabase CLI not found in this repository or PATH" }),
+        /* @__PURE__ */ jsxs13(Box12, { gap: 1, children: [
+          /* @__PURE__ */ jsx13(Text11, { dimColor: true, children: "Install it:" }),
+          /* @__PURE__ */ jsx13(Text11, { color: inkColors.accent, children: "https://supabase.com/docs/guides/cli" })
+        ] })
+      ] })
+    ] }) : /* @__PURE__ */ jsxs13(Box12, { flexDirection: "column", marginY: 1, children: [
+      /* @__PURE__ */ jsxs13(Box12, { gap: 1, children: [
+        /* @__PURE__ */ jsx13(Text11, { color: "red", bold: true, children: "\u2717" }),
+        /* @__PURE__ */ jsx13(Text11, { color: "red", children: "Command failed " }),
+        /* @__PURE__ */ jsx13(Text11, { dimColor: true, children: "(exit code " }),
+        /* @__PURE__ */ jsx13(Text11, { color: "red", bold: true, children: String(result?.exitCode) }),
+        /* @__PURE__ */ jsx13(Text11, { dimColor: true, children: ")" })
+      ] }),
+      /* @__PURE__ */ jsxs13(Box12, { marginLeft: 2, marginTop: 1, children: [
+        /* @__PURE__ */ jsx13(Text11, { dimColor: true, children: "Command: " }),
+        /* @__PURE__ */ jsx13(Text11, { children: cmdDisplay })
+      ] }),
+      !hasDebug && /* @__PURE__ */ jsxs13(Box12, { marginLeft: 2, marginTop: 1, gap: 1, children: [
+        /* @__PURE__ */ jsx13(Text11, { dimColor: true, children: "\u{1F4A1} Tip: retry with" }),
+        /* @__PURE__ */ jsx13(Text11, { color: inkColors.accent, children: "--debug" }),
+        /* @__PURE__ */ jsx13(Text11, { dimColor: true, children: "to see detailed logs" })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx13(Box12, { marginTop: 1, marginBottom: 1, children: /* @__PURE__ */ jsx13(Text11, { bold: true, children: "What would you like to do?" }) }),
+    /* @__PURE__ */ jsx13(
+      SelectList,
+      {
+        items: errorItems,
+        onSelect: async (action) => {
+          switch (action) {
+            case "retry":
+              setPinMessage(void 0);
+              reset();
+              setPhase("running");
+              break;
+            case "retry-debug": {
+              const newArgs = [...currentArgs, "--debug"];
+              setCurrentArgs(newArgs);
+              setPinMessage(void 0);
+              reset();
+              setPhase("running");
+              break;
+            }
+            case "docs":
+              await openInBrowser("https://supabase.com/docs/guides/cli");
+              break;
+            case "copy":
+              await copyToClipboard(cmdDisplay);
+              break;
+            case "menu":
+              onBack();
+              break;
+            case "exit":
+              onExit();
+              break;
+          }
+        },
+        onCancel: onBack
+      }
+    ),
+    /* @__PURE__ */ jsx13(StatusBar, {})
+  ] });
+}
+
+// src/screens/SelfUpdate.tsx
+import { useEffect as useEffect5, useState as useState9 } from "react";
+import { Box as Box13, Text as Text12 } from "ink";
+
+// src/lib/packageRoot.ts
+import { existsSync as existsSync2 } from "fs";
+import { dirname as dirname2, join as join2, resolve as resolve2 } from "path";
+function findNearestPackageRoot(startDir = process.cwd()) {
+  let currentDir = resolve2(startDir);
+  while (true) {
+    if (existsSync2(join2(currentDir, "package.json"))) {
+      return currentDir;
+    }
+    const parentDir = dirname2(currentDir);
+    if (parentDir === currentDir) {
+      return void 0;
+    }
+    currentDir = parentDir;
+  }
+}
+
+// src/screens/SelfUpdate.tsx
+import { jsx as jsx14, jsxs as jsxs14 } from "react/jsx-runtime";
+var packageName = "@polterware/polter";
+var globalUpdateArgs = ["install", "-g", `${packageName}@latest`];
+var repositoryUpdateArgs = ["install", "-D", `${packageName}@latest`];
+function getUpdateArgs(target) {
+  return target === "repository" ? repositoryUpdateArgs : globalUpdateArgs;
+}
+function SelfUpdate({
+  onBack,
+  onExit
+}) {
+  const repositoryRoot = findNearestPackageRoot();
+  const [target, setTarget] = useState9(
+    repositoryRoot ? "repository" : "global"
+  );
+  const [phase, setPhase] = useState9(
+    repositoryRoot ? "target" : "confirm"
+  );
+  const updateArgs = getUpdateArgs(target);
+  const updateDisplay = `npm ${updateArgs.join(" ")}`;
+  const updateCwd = target === "repository" && repositoryRoot ? repositoryRoot : process.cwd();
+  const { status, result, run, reset } = useCommand("npm", updateCwd);
+  useEffect5(() => {
+    if (phase === "running" && status === "idle") {
+      run(updateArgs);
+    }
+  }, [phase, run, status, updateArgs]);
+  useEffect5(() => {
+    if (phase === "running" && status === "success") {
+      setPhase("success");
+    }
+    if (phase === "running" && status === "error") {
+      setPhase("error");
+    }
+  }, [phase, status]);
+  if (phase === "target") {
+    return /* @__PURE__ */ jsxs14(Box13, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx14(Box13, { marginBottom: 1, children: /* @__PURE__ */ jsx14(Text12, { bold: true, children: "Choose where to update Polter." }) }),
+      /* @__PURE__ */ jsx14(
+        SelectList,
+        {
+          items: [
+            {
+              value: "repository",
+              label: "Current repository",
+              hint: "Pin the latest version in package.json"
+            },
+            {
+              value: "global",
+              label: "Global install",
+              hint: "Update the shared version available in PATH"
+            },
+            { value: "back", label: "\u2190 Back to menu" }
+          ],
+          onSelect: (value) => {
+            if (value === "back") {
+              onBack();
+              return;
+            }
+            setTarget(value);
+            reset();
+            setPhase("confirm");
+          },
+          onCancel: onBack
+        }
+      ),
+      repositoryRoot && /* @__PURE__ */ jsx14(Box13, { marginTop: 1, marginLeft: 2, children: /* @__PURE__ */ jsxs14(Text12, { dimColor: true, children: [
+        "Repository root: ",
+        repositoryRoot
+      ] }) })
+    ] });
+  }
+  if (phase === "confirm") {
+    return /* @__PURE__ */ jsxs14(Box13, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx14(
+        ConfirmPrompt,
+        {
+          message: `Run ${updateDisplay}?`,
+          defaultValue: true,
+          onConfirm: (confirmed) => {
+            if (confirmed) {
+              reset();
+              setPhase("running");
+              return;
+            }
+            if (repositoryRoot) {
+              setPhase("target");
+              return;
+            }
+            onBack();
+          }
+        }
+      ),
+      /* @__PURE__ */ jsxs14(Box13, { marginTop: 1, marginLeft: 2, flexDirection: "column", children: [
+        /* @__PURE__ */ jsx14(Text12, { dimColor: true, children: target === "repository" ? "This updates the dependency in the current repository." : "This updates the global npm install." }),
+        target === "repository" && repositoryRoot && /* @__PURE__ */ jsxs14(Text12, { dimColor: true, children: [
+          "Run location: ",
+          repositoryRoot
+        ] })
+      ] })
+    ] });
+  }
+  if (phase === "running") {
+    return /* @__PURE__ */ jsxs14(Box13, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx14(Divider, {}),
+      /* @__PURE__ */ jsxs14(Box13, { marginY: 1, gap: 1, children: [
+        /* @__PURE__ */ jsx14(Text12, { color: inkColors.accent, bold: true, children: "\u25B6" }),
+        /* @__PURE__ */ jsx14(Text12, { dimColor: true, children: "Running:" }),
+        /* @__PURE__ */ jsx14(Text12, { children: updateDisplay })
+      ] }),
+      /* @__PURE__ */ jsx14(Divider, {}),
+      /* @__PURE__ */ jsx14(Box13, { marginTop: 1, children: /* @__PURE__ */ jsx14(Spinner, { label: "Updating Polter..." }) })
+    ] });
+  }
+  if (phase === "success") {
+    return /* @__PURE__ */ jsxs14(Box13, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx14(Divider, {}),
+      /* @__PURE__ */ jsxs14(Box13, { marginY: 1, gap: 1, children: [
+        /* @__PURE__ */ jsx14(Text12, { color: inkColors.accent, bold: true, children: "\u2713" }),
+        /* @__PURE__ */ jsx14(Text12, { color: inkColors.accent, bold: true, children: "Update completed successfully!" })
+      ] }),
+      /* @__PURE__ */ jsxs14(Box13, { marginBottom: 1, marginLeft: 2, flexDirection: "column", children: [
+        /* @__PURE__ */ jsx14(Text12, { dimColor: true, children: "Restart Polter to use the latest version." }),
+        target === "repository" && repositoryRoot && /* @__PURE__ */ jsxs14(Text12, { dimColor: true, children: [
+          "Repository updated in: ",
+          repositoryRoot
+        ] })
+      ] }),
+      /* @__PURE__ */ jsx14(
+        SelectList,
+        {
+          items: [
+            { value: "__back__", label: "\u2190 Back to menu" },
+            { value: "__exit__", label: "\u{1F6AA} Exit Polter" }
+          ],
+          onSelect: (value) => {
+            if (value === "__exit__") {
+              onExit();
+              return;
+            }
+            onBack();
+          },
+          onCancel: onBack
+        }
+      )
+    ] });
+  }
+  return /* @__PURE__ */ jsxs14(Box13, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx14(Divider, {}),
+    result?.spawnError ? /* @__PURE__ */ jsxs14(Box13, { flexDirection: "column", marginY: 1, children: [
+      /* @__PURE__ */ jsxs14(Box13, { gap: 1, children: [
+        /* @__PURE__ */ jsx14(Text12, { color: "red", bold: true, children: "\u2717" }),
+        /* @__PURE__ */ jsx14(Text12, { color: "red", bold: true, children: "Failed to start update" })
+      ] }),
+      /* @__PURE__ */ jsxs14(Box13, { marginLeft: 2, marginTop: 1, children: [
+        /* @__PURE__ */ jsx14(Text12, { dimColor: true, children: "Error: " }),
+        /* @__PURE__ */ jsx14(Text12, { color: "red", children: result.spawnError })
+      ] })
+    ] }) : /* @__PURE__ */ jsxs14(Box13, { flexDirection: "column", marginY: 1, children: [
+      /* @__PURE__ */ jsxs14(Box13, { gap: 1, children: [
+        /* @__PURE__ */ jsx14(Text12, { color: "red", bold: true, children: "\u2717" }),
+        /* @__PURE__ */ jsx14(Text12, { color: "red", children: "Update failed " }),
+        /* @__PURE__ */ jsx14(Text12, { dimColor: true, children: "(exit code " }),
+        /* @__PURE__ */ jsx14(Text12, { color: "red", bold: true, children: String(result?.exitCode) }),
+        /* @__PURE__ */ jsx14(Text12, { dimColor: true, children: ")" })
+      ] }),
+      /* @__PURE__ */ jsxs14(Box13, { marginLeft: 2, marginTop: 1, children: [
+        /* @__PURE__ */ jsx14(Text12, { dimColor: true, children: "Command: " }),
+        /* @__PURE__ */ jsx14(Text12, { children: updateDisplay })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs14(Box13, { marginBottom: 1, marginLeft: 2, flexDirection: "column", children: [
+      /* @__PURE__ */ jsx14(Text12, { dimColor: true, children: "Manual fallback:" }),
+      /* @__PURE__ */ jsx14(Text12, { color: inkColors.accent, children: updateDisplay }),
+      target === "repository" && repositoryRoot && /* @__PURE__ */ jsxs14(Text12, { dimColor: true, children: [
+        "Run location: ",
+        repositoryRoot
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx14(Box13, { marginTop: 1, marginBottom: 1, children: /* @__PURE__ */ jsx14(Text12, { bold: true, children: "What would you like to do?" }) }),
+    /* @__PURE__ */ jsx14(
+      SelectList,
+      {
+        items: [
+          { value: "retry", label: "\u{1F504} Retry update" },
+          ...repositoryRoot ? [{ value: "target", label: "\u2194 Choose update target" }] : [],
+          { value: "menu", label: "\u2190 Return to main menu" },
+          { value: "exit", label: "\u{1F6AA} Exit Polter" }
+        ],
+        onSelect: (value) => {
+          switch (value) {
+            case "retry":
+              reset();
+              setPhase("running");
+              break;
+            case "target":
+              reset();
+              setPhase("target");
+              break;
+            case "menu":
+              onBack();
+              break;
+            case "exit":
+              onExit();
+              break;
+          }
+        },
+        onCancel: onBack
+      }
+    ),
+    /* @__PURE__ */ jsx14(StatusBar, {})
+  ] });
+}
+
+// src/app.tsx
+import { jsx as jsx15, jsxs as jsxs15 } from "react/jsx-runtime";
+function App() {
+  const { screen, params, navigate, goBack } = useNavigation();
+  const { exit } = useApp();
+  const handleExit = () => {
+    process.stdout.write(
+      "\n" + colors.dim("Thank you for using ") + colors.primaryBold("Polter") + colors.dim("!") + "\n\n"
+    );
+    exit();
+  };
+  switch (screen) {
+    case "main-menu":
+      return /* @__PURE__ */ jsx15(MainMenu, { onNavigate: navigate, onExit: handleExit });
+    case "command-args":
+      return /* @__PURE__ */ jsx15(
+        CommandArgs,
+        {
+          command: params.command ?? "",
+          onNavigate: navigate,
+          onBack: goBack
+        }
+      );
+    case "custom-command":
+      return /* @__PURE__ */ jsx15(CustomCommand, { onNavigate: navigate, onBack: goBack });
+    case "flag-selection":
+      return /* @__PURE__ */ jsx15(
+        FlagSelection,
+        {
+          args: params.args ?? [],
+          onNavigate: navigate,
+          onBack: goBack
+        }
+      );
+    case "confirm-execute":
+    case "command-execution":
+      return /* @__PURE__ */ jsx15(
+        CommandExecution,
+        {
+          args: params.args ?? [],
+          onBack: goBack,
+          onExit: handleExit
+        }
+      );
+    case "self-update":
+      return /* @__PURE__ */ jsx15(SelfUpdate, { onBack: goBack, onExit: handleExit });
+    default:
+      return /* @__PURE__ */ jsx15(Box14, { children: /* @__PURE__ */ jsxs15(Text13, { color: "red", children: [
+        "Unknown screen: ",
+        screen
+      ] }) });
+  }
+}
+
+// src/lib/cliArgs.ts
+function takeValue(args, index) {
+  const token = args[index];
+  if (!token) {
+    return { nextIndex: index };
+  }
+  const eqIndex = token.indexOf("=");
+  if (eqIndex >= 0) {
+    return {
+      value: token.slice(eqIndex + 1),
+      nextIndex: index
+    };
+  }
+  return { value: args[index + 1], nextIndex: index + 1 };
+}
+function parseCliArgs(argv) {
+  if (argv.length === 0) {
+    return { mode: "interactive", options: {} };
+  }
+  if (argv[0] === "--help" || argv[0] === "help") {
+    return { mode: "help", options: {} };
+  }
+  if (argv[0] !== "app") {
+    return { mode: "interactive", options: {} };
+  }
+  const options = {};
+  options.action = argv[1];
+  options.app = argv[2];
+  for (let index = 3; index < argv.length; index += 1) {
+    const token = argv[index];
+    if (token === "push" || token === "lint" || token === "reset" || token === "local-reset") {
+      options.migrationAction = token;
+      continue;
+    }
+    if (token === "--yes") {
+      options.yes = true;
+      continue;
+    }
+    if (token === "--relink") {
+      options.relink = true;
+      continue;
+    }
+    if (token === "--create-project") {
+      options.createProject = true;
+      continue;
+    }
+    if (token === "--use-existing-project") {
+      options.useExistingProject = true;
+      continue;
+    }
+    if (token.startsWith("--path")) {
+      const parsed = takeValue(argv, index);
+      options.path = parsed.value;
+      index = parsed.nextIndex;
+      continue;
+    }
+    if (token.startsWith("--version")) {
+      const parsed = takeValue(argv, index);
+      options.version = parsed.value;
+      index = parsed.nextIndex;
+      continue;
+    }
+    if (token.startsWith("--artifact-url")) {
+      const parsed = takeValue(argv, index);
+      options.artifactUrl = parsed.value;
+      index = parsed.nextIndex;
+      continue;
+    }
+    if (token.startsWith("--install-dir")) {
+      const parsed = takeValue(argv, index);
+      options.installDir = parsed.value;
+      index = parsed.nextIndex;
+      continue;
+    }
+  }
+  return {
+    mode: "app",
+    options
+  };
+}
+function printCliHelp() {
+  process.stdout.write(
+    [
+      "Polter",
+      "",
+      "Usage:",
+      "  polter",
+      "  polter app setup ops [--path <dir>] [--create-project|--use-existing-project] [--yes]",
+      "  polter app link ops [--path <dir>] [--relink]",
+      "  polter app migrate ops [push|lint|reset|local-reset] [--path <dir>] [--relink]",
+      "  polter app configure ops [--path <dir>] [--yes]",
+      "  polter app install ops [--version <version>] [--artifact-url <url>] [--install-dir <dir>] [--yes]",
+      "  polter app update ops [--version <version>] [--artifact-url <url>] [--install-dir <dir>] [--yes]",
+      "",
+      "Notes:",
+      "  - App workflows stay separate from the generic Supabase interactive menu.",
+      "  - `install ops` is macOS-only and resolves the latest GitHub release from polterware/ops by default.",
+      "  - `update ops` replaces the installed app bundle without touching the persisted runtime/app state.",
+      "  - Use --artifact-url or POLTER_OPS_MACOS_ARTIFACT_URL to override the downloaded asset.",
+      "  - Use POLTER_OPS_GITHUB_REPO=owner/repo to resolve releases from a different repository.",
+      ""
+    ].join("\n")
+  );
+}
+
+// src/apps/runAppCli.ts
+import pc3 from "picocolors";
+
+// src/apps/ops.ts
+import { existsSync as existsSync3, mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
+import { mkdtemp, readdir, stat } from "fs/promises";
+import { dirname as dirname3, join as join4, resolve as resolve3 } from "path";
+import { tmpdir } from "os";
+import pc2 from "picocolors";
+
+// src/apps/bootstrapPaths.ts
+import { homedir } from "os";
+import { join as join3 } from "path";
+function getOpsBootstrapPayloadPath() {
+  const home = homedir();
+  if (process.platform === "darwin") {
+    return join3(
+      home,
+      "Library",
+      "Application Support",
+      "ops",
+      "bootstrap",
+      "supabase.json"
+    );
+  }
+  if (process.platform === "win32") {
+    const appData = process.env.APPDATA ?? join3(home, "AppData", "Roaming");
+    return join3(appData, "ops", "bootstrap", "supabase.json");
+  }
+  return join3(home, ".config", "ops", "bootstrap", "supabase.json");
+}
+
+// src/apps/opsRelease.ts
+var DEFAULT_OPS_GITHUB_REPO = "polterware/ops";
+var DEFAULT_ARTIFACT_ENV_VAR = "POLTER_OPS_MACOS_ARTIFACT_URL";
+var DEFAULT_GITHUB_REPO_ENV_VAR = "POLTER_OPS_GITHUB_REPO";
+var GITHUB_API_BASE = "https://api.github.com/repos";
+function getGitHubHeaders(env) {
+  const headers = {
+    Accept: "application/vnd.github+json",
+    "X-GitHub-Api-Version": "2022-11-28"
+  };
+  const token = env.GITHUB_TOKEN?.trim() || env.GH_TOKEN?.trim();
+  if (token) {
+    headers.Authorization = `Bearer ${token}`;
+  }
+  return headers;
+}
+function getGitHubReleaseRequestLabel(repo, version) {
+  if (!version) {
+    return `latest release in ${repo}`;
+  }
+  return `release ${version} in ${repo}`;
+}
+function parseGitHubReleaseAsset(value) {
+  if (!value || typeof value !== "object") {
+    return null;
+  }
+  const asset = value;
+  const name = typeof asset.name === "string" ? asset.name.trim() : "";
+  const browserDownloadUrl = typeof asset.browser_download_url === "string" ? asset.browser_download_url.trim() : "";
+  const size = typeof asset.size === "number" ? asset.size : void 0;
+  if (!name || !browserDownloadUrl) {
+    return null;
+  }
+  return {
+    name,
+    browserDownloadUrl,
+    size
+  };
+}
+async function parseGitHubReleaseResponse(response, label) {
+  const body = await response.text();
+  if (!response.ok) {
+    let detail = body.trim();
+    try {
+      const parsed2 = JSON.parse(body);
+      if (typeof parsed2.message === "string" && parsed2.message.trim()) {
+        detail = parsed2.message.trim();
+      }
+    } catch {
+    }
+    throw new Error(
+      `Unable to resolve ${label}: ${response.status} ${response.statusText}${detail ? ` (${detail})` : ""}.`
+    );
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(body);
+  } catch (error) {
+    throw new Error(
+      `Unable to parse ${label} from GitHub: ${error instanceof Error ? error.message : String(error)}.`
+    );
+  }
+  const assets = Array.isArray(parsed.assets) ? parsed.assets.map((asset) => parseGitHubReleaseAsset(asset)).filter((asset) => asset !== null) : [];
+  if (assets.length === 0) {
+    throw new Error(`GitHub ${label} did not contain any downloadable assets.`);
+  }
+  return {
+    tagName: typeof parsed.tag_name === "string" ? parsed.tag_name : null,
+    assets
+  };
+}
+function normalizeOpsReleaseVersion(version) {
+  return version.trim().replace(/^v/i, "");
+}
+function buildVersionTagCandidates(version) {
+  const normalized = normalizeOpsReleaseVersion(version);
+  if (!normalized) {
+    return [];
+  }
+  return Array.from(/* @__PURE__ */ new Set([`v${normalized}`, normalized]));
+}
+async function fetchGitHubRelease(repo, version, fetchImpl, env) {
+  const headers = getGitHubHeaders(env);
+  if (version) {
+    const tagCandidates = buildVersionTagCandidates(version);
+    for (const tag of tagCandidates) {
+      const response2 = await fetchImpl(
+        `${GITHUB_API_BASE}/${repo}/releases/tags/${encodeURIComponent(tag)}`,
+        { headers }
+      );
+      if (response2.status === 404) {
+        continue;
+      }
+      return parseGitHubReleaseResponse(
+        response2,
+        getGitHubReleaseRequestLabel(repo, tag)
+      );
+    }
+    throw new Error(
+      `Unable to find release ${normalizeOpsReleaseVersion(version)} in ${repo}.`
+    );
+  }
+  const response = await fetchImpl(`${GITHUB_API_BASE}/${repo}/releases/latest`, {
+    headers
+  });
+  return parseGitHubReleaseResponse(
+    response,
+    getGitHubReleaseRequestLabel(repo)
+  );
+}
+function getArtifactFileNameFromUrl(url, fallback = "ops-macos.zip") {
+  try {
+    const pathname = new URL(url).pathname;
+    const name = decodeURIComponent(pathname.split("/").pop() ?? "").trim();
+    return name || fallback;
+  } catch {
+    const name = decodeURIComponent(url.split("?")[0]?.split("/").pop() ?? "").trim();
+    return name || fallback;
+  }
+}
+function hasSupportedArchiveFormat(name) {
+  const lowered = name.toLowerCase();
+  return lowered.endsWith(".app.tar.gz") || lowered.endsWith(".zip");
+}
+function hasMacosHint(name) {
+  const lowered = name.toLowerCase();
+  return lowered.endsWith(".app.tar.gz") || lowered.includes(".app.zip") || lowered.includes("macos") || lowered.includes("darwin") || lowered.includes("universal");
+}
+function isSupportedOpsMacosArtifactName(name) {
+  return hasSupportedArchiveFormat(name) && hasMacosHint(name);
+}
+function getArchAliases(arch) {
+  switch (arch) {
+    case "arm64":
+    case "aarch64":
+      return ["arm64", "aarch64"];
+    case "x64":
+    case "x86_64":
+    case "amd64":
+      return ["x64", "x86_64", "amd64"];
+    default:
+      return [arch.toLowerCase()];
+  }
+}
+function hasAnyArchHint(name) {
+  return /(arm64|aarch64|x64|x86_64|amd64)/.test(name.toLowerCase());
+}
+function getArchPriority(name, arch) {
+  const lowered = name.toLowerCase();
+  if (lowered.includes("universal")) {
+    return 0;
+  }
+  const aliases = getArchAliases(arch);
+  if (aliases.some((alias) => lowered.includes(alias))) {
+    return 1;
+  }
+  if (hasAnyArchHint(lowered)) {
+    return 3;
+  }
+  return 2;
+}
+function getFormatPriority(name) {
+  return name.toLowerCase().endsWith(".app.tar.gz") ? 0 : 1;
+}
+function selectOpsMacosReleaseAsset(assets, arch = process.arch) {
+  const supported = assets.map((asset, index) => ({ asset, index })).filter(({ asset }) => isSupportedOpsMacosArtifactName(asset.name)).sort((left, right) => {
+    const archPriority = getArchPriority(left.asset.name, arch) - getArchPriority(right.asset.name, arch);
+    if (archPriority !== 0) {
+      return archPriority;
+    }
+    const formatPriority = getFormatPriority(left.asset.name) - getFormatPriority(right.asset.name);
+    if (formatPriority !== 0) {
+      return formatPriority;
+    }
+    return left.index - right.index;
+  });
+  if (supported.length === 0) {
+    const names = assets.map((asset) => asset.name).join(", ");
+    throw new Error(
+      `No supported macOS archive was found in the release. Expected a .app.tar.gz or .zip asset for macOS, found: ${names}.`
+    );
+  }
+  return supported[0].asset;
+}
+async function resolveOpsMacosArtifact(options, env = process.env, fetchImpl = fetch, arch = process.arch) {
+  const explicitUrl = options.artifactUrl?.trim() || env[DEFAULT_ARTIFACT_ENV_VAR]?.trim();
+  if (explicitUrl) {
+    return {
+      url: explicitUrl,
+      fileName: getArtifactFileNameFromUrl(explicitUrl),
+      source: "explicit-url"
+    };
+  }
+  const repo = env[DEFAULT_GITHUB_REPO_ENV_VAR]?.trim() || DEFAULT_OPS_GITHUB_REPO;
+  const release = await fetchGitHubRelease(repo, options.version, fetchImpl, env);
+  const asset = selectOpsMacosReleaseAsset(release.assets, arch);
+  return {
+    url: asset.browserDownloadUrl,
+    fileName: asset.name,
+    size: asset.size,
+    source: "github-release",
+    repo,
+    tagName: release.tagName
+  };
+}
+
+// src/lib/prompts.ts
+import { createInterface } from "readline/promises";
+import { stdin as input, stdout as output } from "process";
+async function promptText(label, options = {}) {
+  const rl = createInterface({ input, output });
+  try {
+    while (true) {
+      const suffix = options.defaultValue ? ` (${options.defaultValue})` : "";
+      const answer = (await rl.question(`${label}${suffix}: `)).trim();
+      if (!answer && options.defaultValue) {
+        return options.defaultValue;
+      }
+      if (!answer && options.required) {
+        output.write("This value is required.\n");
+        continue;
+      }
+      return answer;
+    }
+  } finally {
+    rl.close();
+  }
+}
+async function promptConfirm(label, defaultValue = true) {
+  const rl = createInterface({ input, output });
+  try {
+    const answer = (await rl.question(`${label} ${defaultValue ? "(Y/n)" : "(y/N)"}: `)).trim().toLowerCase();
+    if (!answer) {
+      return defaultValue;
+    }
+    return answer === "y" || answer === "yes";
+  } finally {
+    rl.close();
+  }
+}
+async function promptSelect(label, options, defaultValue) {
+  const rl = createInterface({ input, output });
+  try {
+    output.write(`${label}
+`);
+    for (const [index, option] of options.entries()) {
+      const marker = option.value === defaultValue ? " (default)" : "";
+      output.write(`  ${index + 1}. ${option.label}${marker}
+`);
+    }
+    while (true) {
+      const answer = (await rl.question(
+        `Choose 1-${options.length}${defaultValue ? " (press Enter for default)" : ""}: `
+      )).trim();
+      if (!answer && defaultValue) {
+        return defaultValue;
+      }
+      const selectedIndex = Number(answer);
+      if (Number.isInteger(selectedIndex) && selectedIndex >= 1 && selectedIndex <= options.length) {
+        return options[selectedIndex - 1].value;
+      }
+      output.write("Invalid selection.\n");
+    }
+  } finally {
+    rl.close();
+  }
+}
+
+// src/lib/system.ts
+import { execSync } from "child_process";
+function commandExists(command) {
+  try {
+    execSync(`command -v ${command}`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/apps/ops.ts
+var LINK_REF_FILE = join4("supabase", ".temp", "project-ref");
+function isOpsProjectRoot(candidate) {
+  return existsSync3(join4(candidate, "src-tauri", "tauri.conf.json")) && existsSync3(join4(candidate, "supabase", "migrations")) && existsSync3(join4(candidate, "package.json"));
+}
+function findNearestOpsRoot(startDir) {
+  let currentDir = resolve3(startDir);
+  while (true) {
+    if (isOpsProjectRoot(currentDir)) {
+      return currentDir;
+    }
+    const siblingCandidate = join4(currentDir, "ops");
+    if (isOpsProjectRoot(siblingCandidate)) {
+      return siblingCandidate;
+    }
+    const parentDir = dirname3(currentDir);
+    if (parentDir === currentDir) {
+      return void 0;
+    }
+    currentDir = parentDir;
+  }
+}
+function readEnvFile(envPath) {
+  if (!existsSync3(envPath)) {
+    return {};
+  }
+  const content = readFileSync(envPath, "utf-8");
+  const entries = {};
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) {
+      continue;
+    }
+    const eqIndex = trimmed.indexOf("=");
+    if (eqIndex === -1) {
+      continue;
+    }
+    const key = trimmed.slice(0, eqIndex).trim();
+    const value = trimmed.slice(eqIndex + 1).trim();
+    entries[key] = value;
+  }
+  return entries;
+}
+function writeEnvFile(envPath, nextEnv) {
+  const content = Object.entries(nextEnv).map(([key, value]) => `${key}=${value}`).join("\n");
+  writeFileSync(envPath, `${content}
+`);
+}
+function assertProjectRoot(projectRoot) {
+  if (!projectRoot) {
+    throw new Error(
+      "Could not resolve the Ops project root. Run from the Ops repository or pass --path."
+    );
+  }
+  return projectRoot;
+}
+function getLinkedProjectRef(projectRoot) {
+  const refPath = join4(projectRoot, LINK_REF_FILE);
+  if (!existsSync3(refPath)) {
+    return null;
+  }
+  const value = readFileSync(refPath, "utf-8").trim();
+  return value || null;
+}
+function getDbPasswordArgs() {
+  const password = process.env.SUPABASE_DB_PASSWORD?.trim();
+  return password ? ["--password", password] : [];
+}
+async function ensurePrerequisites() {
+  const checks = [
+    { command: "node", label: "Node.js" },
+    { command: "pnpm", label: "pnpm" },
+    { command: "supabase", label: "Supabase CLI" }
+  ];
+  const missing = checks.filter((check) => !commandExists(check.command));
+  if (missing.length > 0) {
+    throw new Error(
+      `Missing required tools: ${missing.map((item) => item.label).join(", ")}`
+    );
+  }
+}
+async function runOrThrow(execution, args, cwd, failureMessage) {
+  const result = await runCommand(execution, args, cwd);
+  if (result.spawnError || result.exitCode !== 0) {
+    throw new Error(
+      result.stderr.trim() || result.spawnError || failureMessage
+    );
+  }
+}
+async function runSupabaseOrThrow(args, cwd, failureMessage) {
+  const result = await runSupabaseCommand(args, cwd);
+  if (result.spawnError || result.exitCode !== 0) {
+    throw new Error(
+      result.stderr.trim() || result.spawnError || failureMessage
+    );
+  }
+}
+async function ensureSupabaseLink(projectRoot, forceRelink = false) {
+  const linkedRef = getLinkedProjectRef(projectRoot);
+  if (linkedRef && !forceRelink) {
+    process.stdout.write(`${pc2.dim(`Linked project: ${linkedRef}`)}
+`);
+    return;
+  }
+  process.stdout.write(
+    `${pc2.dim(forceRelink ? "Relinking Supabase project..." : "Linking Supabase project...")}
+`
+  );
+  await runSupabaseOrThrow(
+    ["link", ...getDbPasswordArgs()],
+    projectRoot,
+    "Supabase link failed."
+  );
+}
+async function collectSupabaseConfig(projectRoot) {
+  const envPath = projectRoot ? join4(projectRoot, ".env.local") : void 0;
+  const currentEnv = envPath ? readEnvFile(envPath) : {};
+  const currentRef = projectRoot ? getLinkedProjectRef(projectRoot) : null;
+  const url = await promptText("Supabase URL", {
+    defaultValue: currentEnv.VITE_SUPABASE_URL,
+    required: true
+  });
+  const publishableKey = await promptText("Supabase publishable key", {
+    defaultValue: currentEnv.VITE_SUPABASE_PUBLISHABLE_DEFAULT_KEY,
+    required: true
+  });
+  const projectRef = await promptText("Supabase project ref", {
+    defaultValue: currentRef ?? "",
+    required: true
+  });
+  return {
+    url: url.trim().replace(/\/$/, ""),
+    publishableKey: publishableKey.trim(),
+    projectRef: projectRef.trim()
+  };
+}
+function writeOpsEnv(projectRoot, config2) {
+  const envPath = join4(projectRoot, ".env.local");
+  const currentEnv = readEnvFile(envPath);
+  const nextEnv = {
+    ...currentEnv,
+    VITE_SUPABASE_URL: config2.url,
+    VITE_SUPABASE_PUBLISHABLE_DEFAULT_KEY: config2.publishableKey
+  };
+  writeEnvFile(envPath, nextEnv);
+}
+function writeBootstrapPayload(config2) {
+  const payloadPath = getOpsBootstrapPayloadPath();
+  mkdirSync(dirname3(payloadPath), { recursive: true });
+  writeFileSync(
+    payloadPath,
+    JSON.stringify(
+      {
+        url: config2.url,
+        publishableKey: config2.publishableKey,
+        projectRef: config2.projectRef,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        source: "polter"
+      },
+      null,
+      2
+    )
+  );
+  return payloadPath;
+}
+async function promptProjectMode(options) {
+  if (options.useExistingProject) {
+    return "existing";
+  }
+  if (options.createProject) {
+    return "create";
+  }
+  const selected = await promptSelect(
+    "How should Polter prepare Supabase for Ops?",
+    [
+      { value: "existing", label: "Use an existing Supabase project" },
+      { value: "create", label: "Create a new Supabase project first" }
+    ],
+    "existing"
+  );
+  return selected;
+}
+async function runSetup(context) {
+  const projectRoot = assertProjectRoot(context.projectRoot);
+  await ensurePrerequisites();
+  const mode = await promptProjectMode(context.options);
+  if (mode === "create") {
+    process.stdout.write(
+      `${pc2.dim("Launching interactive Supabase project creation...")}
+`
+    );
+    await runSupabaseOrThrow(
+      ["projects", "create"],
+      projectRoot,
+      "Supabase project creation failed."
+    );
+  }
+  const config2 = await collectSupabaseConfig(projectRoot);
+  writeOpsEnv(projectRoot, config2);
+  process.stdout.write(`${pc2.green("Saved .env.local")}
+`);
+  process.stdout.write(`${pc2.dim("Installing project dependencies...")}
+`);
+  await runOrThrow(
+    "pnpm",
+    ["install", "--frozen-lockfile"],
+    projectRoot,
+    "Dependency installation failed."
+  );
+  await ensureSupabaseLink(projectRoot, context.options.relink);
+  process.stdout.write(`${pc2.dim("Pushing migrations to linked project...")}
+`);
+  await runSupabaseOrThrow(
+    ["db", "push", "--linked", ...getDbPasswordArgs()],
+    projectRoot,
+    "Migration push failed."
+  );
+  const payloadPath = writeBootstrapPayload(config2);
+  process.stdout.write(`${pc2.green("Prepared runtime bootstrap payload")}
+`);
+  process.stdout.write(`${pc2.dim(`Payload path: ${payloadPath}`)}
+`);
+  return 0;
+}
+async function runLink(context) {
+  const projectRoot = assertProjectRoot(context.projectRoot);
+  await ensurePrerequisites();
+  await ensureSupabaseLink(projectRoot, true);
+  process.stdout.write(`${pc2.green("Supabase link completed")}
+`);
+  return 0;
+}
+async function runMigration(context, action) {
+  const projectRoot = assertProjectRoot(context.projectRoot);
+  await ensurePrerequisites();
+  switch (action) {
+    case "local-reset":
+      await runSupabaseOrThrow(
+        ["db", "reset", "--local"],
+        projectRoot,
+        "Local reset failed."
+      );
+      process.stdout.write(`${pc2.green("Local Supabase reset completed")}
+`);
+      return 0;
+    case "push":
+      await ensureSupabaseLink(projectRoot, context.options.relink);
+      await runSupabaseOrThrow(
+        ["db", "push", "--linked", ...getDbPasswordArgs()],
+        projectRoot,
+        "Migration push failed."
+      );
+      process.stdout.write(`${pc2.green("Migrations pushed")}
+`);
+      return 0;
+    case "lint":
+      await ensureSupabaseLink(projectRoot, context.options.relink);
+      await runSupabaseOrThrow(
+        ["db", "lint", "--linked"],
+        projectRoot,
+        "Migration lint completed."
+      );
+      process.stdout.write(`${pc2.green("Migration lint completed")}
+`);
+      return 0;
+    case "reset":
+      await ensureSupabaseLink(projectRoot, context.options.relink);
+      if (!context.options.yes) {
+        const confirmed = await promptConfirm(
+          "This will reset the linked remote database. Continue?",
+          false
+        );
+        if (!confirmed) {
+          process.stdout.write(`${pc2.yellow("Cancelled.")}
+`);
+          return 0;
+        }
+      }
+      await runSupabaseOrThrow(
+        ["db", "reset", "--linked", ...getDbPasswordArgs()],
+        projectRoot,
+        "Remote reset failed."
+      );
+      process.stdout.write(`${pc2.green("Remote reset completed")}
+`);
+      return 0;
+  }
+}
+async function runConfigure(context) {
+  const projectRoot = context.projectRoot;
+  const config2 = await collectSupabaseConfig(projectRoot);
+  if (projectRoot) {
+    writeOpsEnv(projectRoot, config2);
+    process.stdout.write(`${pc2.green("Updated .env.local")}
+`);
+  }
+  const payloadPath = writeBootstrapPayload(config2);
+  process.stdout.write(`${pc2.green("Updated runtime bootstrap payload")}
+`);
+  process.stdout.write(`${pc2.dim(`Payload path: ${payloadPath}`)}
+`);
+  return 0;
+}
+async function downloadFile(url, destinationPath) {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Unable to download artifact: ${response.status} ${response.statusText}`);
+  }
+  const arrayBuffer = await response.arrayBuffer();
+  const buffer = Buffer.from(arrayBuffer);
+  writeFileSync(destinationPath, buffer);
+  return buffer.byteLength;
+}
+async function extractArchive(archivePath, outputDir) {
+  if (archivePath.endsWith(".zip")) {
+    await runOrThrow(
+      "ditto",
+      ["-xk", archivePath, outputDir],
+      process.cwd(),
+      "Archive extraction failed."
+    );
+    return;
+  }
+  if (archivePath.endsWith(".tar.gz") || archivePath.endsWith(".tgz")) {
+    await runOrThrow(
+      "tar",
+      ["-xzf", archivePath, "-C", outputDir],
+      process.cwd(),
+      "Archive extraction failed."
+    );
+    return;
+  }
+  throw new Error("Unsupported artifact format. Use a .zip or .tar.gz macOS artifact.");
+}
+async function findFirstAppBundle(dir) {
+  const entries = await readdir(dir);
+  for (const entry of entries) {
+    const fullPath = join4(dir, entry);
+    const entryStat = await stat(fullPath);
+    if (entryStat.isDirectory() && entry.endsWith(".app")) {
+      return fullPath;
+    }
+    if (entryStat.isDirectory()) {
+      const nested = await findFirstAppBundle(fullPath);
+      if (nested) {
+        return nested;
+      }
+    }
+  }
+  return void 0;
+}
+async function deployMacosApp(context, options) {
+  const artifact = await resolveOpsMacosArtifact(context.options);
+  const tempRoot = await mkdtemp(join4(tmpdir(), "polter-ops-"));
+  const archivePath = join4(tempRoot, artifact.fileName);
+  const extractDir = join4(tempRoot, "extract");
+  mkdirSync(extractDir, { recursive: true });
+  if (artifact.source === "github-release") {
+    const releaseLabel = artifact.tagName ?? "latest";
+    process.stdout.write(
+      `${pc2.dim(`Resolved ${artifact.fileName} from ${artifact.repo} (${releaseLabel})`)}
+`
+    );
+  } else {
+    process.stdout.write(`${pc2.dim(`Using explicit artifact URL: ${artifact.url}`)}
+`);
+  }
+  process.stdout.write(`${pc2.dim("Downloading Ops macOS artifact...")}
+`);
+  const downloadedSize = await downloadFile(artifact.url, archivePath);
+  if (artifact.size && downloadedSize !== artifact.size) {
+    throw new Error(
+      `Downloaded file size mismatch for ${artifact.fileName}. Expected ${artifact.size} bytes but received ${downloadedSize}.`
+    );
+  }
+  process.stdout.write(`${pc2.dim("Extracting artifact...")}
+`);
+  await extractArchive(archivePath, extractDir);
+  const appBundle = await findFirstAppBundle(extractDir);
+  if (!appBundle) {
+    throw new Error("No .app bundle was found inside the downloaded artifact.");
+  }
+  const installDir = context.options.installDir ?? "/Applications";
+  mkdirSync(installDir, { recursive: true });
+  const destination = join4(installDir, "ops.app");
+  if (options.requireExistingInstallation && !existsSync3(destination)) {
+    throw new Error(
+      `No existing Ops installation was found at ${destination}. Run \`polter app install ops\` first.`
+    );
+  }
+  if (existsSync3(destination)) {
+    const confirmed = context.options.yes || await promptConfirm(`Replace existing installation at ${destination}?`, false);
+    if (!confirmed) {
+      process.stdout.write(`${pc2.yellow("Cancelled.")}
+`);
+      return 0;
+    }
+    rmSync(destination, { recursive: true, force: true });
+  }
+  await runOrThrow(
+    "cp",
+    ["-R", appBundle, destination],
+    process.cwd(),
+    "App copy failed."
+  );
+  process.stdout.write(
+    `${pc2.green(`${options.mode === "install" ? "Installed" : "Updated"} Ops at ${destination}`)}
+`
+  );
+  if (options.configureAfterCopy) {
+    await runConfigure(context);
+  } else {
+    process.stdout.write(
+      `${pc2.dim("Preserved existing runtime configuration and local app state.")}
+`
+    );
+  }
+  const shouldOpen = context.options.yes || await promptConfirm("Open Ops now?", true);
+  if (shouldOpen) {
+    await runOrThrow("open", ["-a", destination], process.cwd(), "Unable to open Ops.");
+  }
+  return 0;
+}
+async function installMacosApp(context) {
+  return deployMacosApp(context, {
+    mode: "install",
+    configureAfterCopy: true,
+    requireExistingInstallation: false
+  });
+}
+async function updateMacosApp(context) {
+  return deployMacosApp(context, {
+    mode: "update",
+    configureAfterCopy: false,
+    requireExistingInstallation: true
+  });
+}
+var opsProfile = {
+  id: "ops",
+  displayName: "Ops",
+  detect(startDir = process.cwd()) {
+    return findNearestOpsRoot(startDir);
+  },
+  resolveProjectRoot(startDir = process.cwd(), explicitPath) {
+    if (explicitPath) {
+      const resolved = resolve3(explicitPath);
+      if (isOpsProjectRoot(resolved)) {
+        return resolved;
+      }
+      return findNearestOpsRoot(resolved);
+    }
+    return findNearestOpsRoot(startDir);
+  },
+  async run(action, context) {
+    switch (action) {
+      case "setup":
+        return runSetup(context);
+      case "link":
+        return runLink(context);
+      case "configure":
+        return runConfigure(context);
+      case "install":
+        return installMacosApp(context);
+      case "update":
+        return updateMacosApp(context);
+      case "migrate":
+        return runMigration(
+          context,
+          context.options.migrationAction ?? "push"
+        );
+    }
+  }
+};
+
+// src/apps/registry.ts
+var profiles = [opsProfile];
+function getAppProfile(appId) {
+  return profiles.find((profile) => profile.id === appId);
+}
+
+// src/apps/runAppCli.ts
+function assertAppCommand(options) {
+  if (!options.action || !options.app) {
+    throw new Error("Usage: polter app <setup|link|migrate|configure|install|update> <app>");
+  }
+}
+async function runAppCli(options) {
+  assertAppCommand(options);
+  const profile = getAppProfile(options.app);
+  if (!profile) {
+    throw new Error(`Unknown app profile: ${options.app}`);
+  }
+  const projectRoot = profile.resolveProjectRoot(process.cwd(), options.path);
+  process.stdout.write(
+    `${pc3.bold("Polter")} ${pc3.dim("app workflow")} ${pc3.bold(profile.displayName)} ${pc3.dim(`(${options.action})`)}
+
+`
+  );
+  return profile.run(options.action, {
+    cwd: process.cwd(),
+    projectRoot,
+    options
+  });
+}
+
+// src/index.tsx
+async function main() {
+  const parsed = parseCliArgs(process.argv.slice(2));
+  if (parsed.mode === "help") {
+    printCliHelp();
+    return;
+  }
+  if (parsed.mode === "app") {
+    const exitCode = await runAppCli(parsed.options);
+    process.exit(exitCode);
+  }
+  render(React8.createElement(App));
+}
+main().catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  process.stderr.write(`${message}
+`);
+  process.exit(1);
+});