@polterware/polterbase 0.1.2 → 0.2.1

package/dist/index.js

@@ -1,225 +1,1667 @@
 #!/usr/bin/env node
 
-// src/index.ts
-import * as p from "@clack/prompts";
+// src/index.tsx
+import React7 from "react";
+import { render } from "ink";
+
+// src/app.tsx
+import { Box as Box13, Text as Text12, useApp } from "ink";
+import pc2 from "picocolors";
+
+// 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 pc from "picocolors";
-import { spawn } from "child_process";
-import Conf from "conf";
-var config = new Conf({ projectName: "polterbase" });
-var supabaseCommands = {
-  "Quick Start": [
-    { value: "bootstrap", label: "bootstrap - Bootstrap a Supabase project from a starter template" }
-  ],
-  "Local Development": [
-    { value: "db", label: "db - Manage Postgres databases" },
-    { value: "gen", label: "gen - Run code generation tools" },
-    { value: "init", label: "init - Initialize a local project" },
-    { value: "inspect", label: "inspect - Tools to inspect your Supabase project" },
-    { value: "link", label: "link - Link to a Supabase project" },
-    { value: "login", label: "login - Authenticate using an access token" },
-    { value: "logout", label: "logout - Log out and delete access tokens locally" },
-    { value: "migration", label: "migration - Manage database migration scripts" },
-    { value: "seed", label: "seed - Seed a Supabase project from supabase/config.toml" },
-    { value: "services", label: "services - Show versions of all Supabase services" },
-    { value: "start", label: "start - Start containers for Supabase local development" },
-    { value: "status", label: "status - Show status of local Supabase containers" },
-    { value: "stop", label: "stop - Stop all local Supabase containers" },
-    { value: "test", label: "test - Run tests on local Supabase containers" },
-    { value: "unlink", label: "unlink - Unlink a Supabase project" }
-  ],
-  "Management APIs": [
-    { value: "backups", label: "backups - Manage Supabase physical backups" },
-    { value: "branches", label: "branches - Manage Supabase preview branches" },
-    { value: "config", label: "config - Manage Supabase project configurations" },
-    { value: "domains", label: "domains - Manage custom domain names for Supabase projects" },
-    { value: "encryption", label: "encryption - Manage encryption keys of Supabase projects" },
-    { value: "functions", label: "functions - Manage Supabase Edge functions" },
-    { value: "network-bans", label: "network-bans - Manage network bans" },
-    { value: "network-restrictions", label: "network-restrictions - Manage network restrictions" },
-    { value: "orgs", label: "orgs - Manage Supabase organizations" },
-    { value: "postgres-config", label: "postgres-config - Manage Postgres database config" },
-    { value: "projects", label: "projects - Manage Supabase projects" },
-    { value: "secrets", label: "secrets - Manage Supabase secrets" },
-    { value: "snippets", label: "snippets - Manage Supabase SQL snippets" },
-    { value: "ssl-enforcement", label: "ssl-enforcement - Manage SSL enforcement configuration" },
-    { value: "sso", label: "sso - Manage Single Sign-On (SSO) authentication for projects" },
-    { value: "storage", label: "storage - Manage Supabase Storage objects" },
-    { value: "vanity-subdomains", label: "vanity-subdomains - Manage vanity subdomains for Supabase projects" }
-  ],
-  "Additional Commands": [
-    { value: "completion", label: "completion - Generate the autocompletion script" },
-    { value: "help", label: "help - Help about any command" }
+var VERSION = "0.1.2";
+var colors = {
+  primary: pc.cyan,
+  primaryBold: (s) => pc.bold(pc.cyan(s)),
+  accent: pc.magenta,
+  accentBold: (s) => pc.bold(pc.magenta(s)),
+  success: pc.green,
+  successBold: (s) => pc.bold(pc.green(s)),
+  error: pc.red,
+  errorBold: (s) => pc.bold(pc.red(s)),
+  warning: pc.yellow,
+  warningBold: (s) => pc.bold(pc.yellow(s)),
+  dim: pc.dim,
+  bold: pc.bold,
+  white: pc.white,
+  highlight: (s) => pc.bgCyan(pc.black(pc.bold(s)))
+};
+var ghost = {
+  art: [
+    "    \u2584\u2584\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"
   ]
 };
-var globalFlags = [
-  { value: "--create-ticket", label: "--create-ticket (Create support ticket on error)" },
-  { value: "--debug", label: "--debug (Output debug logs)" },
-  { value: "--experimental", label: "--experimental (Enable experimental features)" },
-  { value: "--yes", label: "--yes (Answer yes to all prompts)" }
-];
-function getPinnedCommands() {
-  return config.get("pinnedCommands") || [];
+
+// 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: "cyan", children: line }, i)) }),
+    /* @__PURE__ */ jsxs(
+      Box,
+      {
+        flexDirection: "column",
+        borderStyle: "single",
+        borderColor: "cyan",
+        paddingX: 1,
+        children: [
+          /* @__PURE__ */ jsx(Text, { backgroundColor: "cyan", color: "black", bold: true, children: " POLTERBASE " }),
+          /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+            "Version: ",
+            VERSION
+          ] }),
+          /* @__PURE__ */ jsx(Text, { dimColor: true, children: "The modern interactive CLI for Supabase" })
+        ]
+      }
+    )
+  ] });
 }
-function addPinnedCommand(cmd) {
-  const current = getPinnedCommands();
-  if (!current.includes(cmd)) {
-    config.set("pinnedCommands", [...current, cmd]);
+
+// 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 removePinnedCommand(cmd) {
-  const current = getPinnedCommands();
-  config.set("pinnedCommands", current.filter((c) => c !== cmd));
-}
-async function main() {
-  console.clear();
-  p.intro(`${pc.bgGreen(pc.black(" POLTERBASE "))} The ultimate modern CLI for Supabase`);
-  let shouldExit = false;
-  while (!shouldExit) {
-    const pinned = getPinnedCommands();
-    const mainOptions = [
-      { value: "Quick Start", label: "Quick Start (Bootstrap templates)" },
-      { value: "Local Development", label: "Local Development (db, init, start, etc.)" },
-      { value: "Management APIs", label: "Management APIs (projects, secrets, domains, etc.)" },
-      { value: "Additional Commands", label: "Additional Commands (help, completion)" },
-      { value: "Custom", label: "Custom Command / Check Version" }
-    ];
-    if (pinned.length > 0) {
-      mainOptions.unshift(
-        { value: "MANAGE_PINS", label: pc.magenta("\u2699\uFE0F Manage Pinned Commands") },
-        ...pinned.map((cmd) => ({ value: `PIN:${cmd}`, label: `${pc.cyan("\u{1F4CC}")} ${cmd}` })),
-        // @ts-ignore
-        { value: "SEPARATOR", label: pc.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"), disabled: true }
-      );
+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;
     }
-    mainOptions.push({ value: "EXIT", label: pc.red("Exit Polterbase") });
-    const category = await p.select({
-      message: "What kind of Supabase command do you want to run?",
-      // @ts-ignore
-      options: mainOptions.filter((opt) => opt.value !== "SEPARATOR"),
-      maxItems: 12
-    });
-    if (p.isCancel(category) || category === "EXIT") {
-      p.cancel("See you later!");
-      process.exit(0);
-    }
-    if (category === "MANAGE_PINS") {
-      const toRemove = await p.multiselect({
-        message: "Select commands to remove from pins (Space to select):",
-        options: pinned.map((cmd) => ({ value: cmd, label: cmd })),
-        required: false
+    if (currentRows.length === 0) {
+      sections.push({
+        type: "heading",
+        key: currentKey ?? `heading-${sections.length}`,
+        label: currentTitle ?? ""
       });
-      if (!p.isCancel(toRemove) && Array.isArray(toRemove)) {
-        toRemove.forEach((cmd) => removePinnedCommand(cmd));
-        p.log.success("Pins updated!");
-      }
+    } 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;
     }
-    let finalArgs = [];
-    let isPinnedExecution = false;
-    if (typeof category === "string" && category.startsWith("PIN:")) {
-      const cmdStr = category.replace("PIN:", "");
-      finalArgs = cmdStr.split(" ");
-      isPinnedExecution = true;
-    } else {
-      let commandValue = "";
-      if (category === "Custom") {
-        const custom = await p.text({
-          message: 'Enter your custom supabase command/flags (e.g., "-v" or "status -o json"):',
-          placeholder: "-v"
-        });
-        if (p.isCancel(custom)) continue;
-        commandValue = custom;
-      } else {
-        const options = [
-          { value: "BACK", label: pc.yellow("\u2190 Go Back") },
-          // @ts-ignore
-          ...supabaseCommands[category]
-        ];
-        const command = await p.select({
-          message: `Select a command from ${category}:`,
-          options,
-          maxItems: 11
-        });
-        if (p.isCancel(command) || command === "BACK") continue;
-        const extraArgs = await p.text({
-          message: `Any additional sub-commands or arguments for "supabase ${command}"?`,
-          placeholder: 'e.g., "push", "pull", "list" (Press Enter to skip)',
-          initialValue: ""
-        });
-        if (p.isCancel(extraArgs)) continue;
-        commandValue = `${command} ${extraArgs}`.trim();
-      }
-      const selectedFlags = await p.multiselect({
-        message: "Select any global flags you want to include (Space to select, Enter to confirm):",
-        options: globalFlags,
-        required: false
+    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((input, key) => {
+    if (selectableIndexes.length === 0) {
+      if (key.escape && onCancel) {
+        onCancel();
+      }
+      return;
+    }
+    if (key.upArrow || input === "k") {
+      setSelectedSelectableIndex((prev) => {
+        let next = prev - 1;
+        if (next < 0) next = selectableIndexes.length - 1;
+        return next;
+      });
+    }
+    if (key.downArrow || input === "j") {
+      setSelectedSelectableIndex((prev) => {
+        let next = prev + 1;
+        if (next >= selectableIndexes.length) next = 0;
+        return next;
       });
-      if (p.isCancel(selectedFlags)) continue;
-      finalArgs = commandValue.split(" ").filter(Boolean);
-      if (Array.isArray(selectedFlags) && selectedFlags.length > 0) {
-        finalArgs = finalArgs.concat(selectedFlags);
+    }
+    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;
       }
     }
-    const finalCmdString = `supabase ${finalArgs.join(" ")}`;
-    const confirm2 = await p.confirm({
-      message: `Ready to execute: ${pc.cyan(finalCmdString)}. Continue?`,
-      initialValue: true
+    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 ? "cyan" : void 0, children: isSelected ? "\u276F" : " " }),
+      /* @__PURE__ */ jsx2(Box2, { width: labelWidth, children: /* @__PURE__ */ jsxs2(
+        Text2,
+        {
+          color: isSelected ? "cyan" : 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: "yellow", 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: hasSelectedRow ? "cyan" : isPinnedSection ? "green" : "yellow",
+          paddingX: 1,
+          children: [
+            section.title && /* @__PURE__ */ jsx2(Text2, { color: hasSelectedRow ? "cyan" : "yellow", 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: "yellow", 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: [
+      "polterbase v",
+      VERSION
+    ] })
+  ] });
+}
+
+// src/data/pins.ts
+import Conf from "conf";
+var config = new Conf({
+  projectName: process.env.NODE_ENV === "test" ? "polterbase-test" : "polterbase"
+});
+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(runCommand) {
+  ensurePinsInitialized();
+  const current = getPinnedRuns();
+  if (current.includes(runCommand)) {
+    setPinnedRuns(current.filter((run) => run !== runCommand));
+    return;
+  }
+  setPinnedRuns([runCommand, ...current.filter((run) => run !== runCommand)]);
+}
+function isPinnedRun(runCommand) {
+  return getPinnedRuns().includes(runCommand);
+}
+
+// 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
     });
-    if (p.isCancel(confirm2)) continue;
-    if (!confirm2) {
-      const action = await p.select({
-        message: "Command cancelled. What next?",
-        options: [
-          { value: "RETRY", label: "Try another command" },
-          { value: "EXIT", label: "Exit" }
-        ]
+    for (const runCommand of pinnedRuns) {
+      const baseCommand = runCommand.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:${runCommand}`,
+        value: runCommand,
+        label: runCommand,
+        hint: infoHint,
+        icon: "\u25B6",
+        kind: "run",
+        rightActionable: true,
+        section: "pinned-runs"
       });
-      if (action === "RETRY") continue;
-      break;
     }
-    p.outro(`Executing: ${pc.cyan(finalCmdString)}`);
-    const child = spawn("supabase", finalArgs, {
-      stdio: "inherit",
-      shell: true
+  }
+  if (pinnedCommands.length > 0) {
+    nextItems.push({
+      id: "section-pinned-commands",
+      value: "__section_pinned_commands__",
+      label: "\u{1F4CC} Pinned Commands",
+      kind: "header",
+      selectable: false
     });
-    await new Promise((resolve) => {
-      child.on("error", (err) => {
-        console.error(pc.red(`Failed to start command: ${err.message}`));
-        resolve();
+    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"
       });
-      child.on("exit", (code) => {
-        if (code !== 0) {
-          console.log(pc.red(`
-Command exited with code ${code}`));
-        } else {
-          console.log(pc.green("\nCommand finished successfully!"));
-          if (!isPinnedExecution && !getPinnedCommands().includes(finalArgs.join(" "))) {
-            setTimeout(async () => {
-              const shouldPin = await p.confirm({
-                message: pc.magenta("Pin this command for easy access next time?"),
-                initialValue: false
-              });
-              if (shouldPin && !p.isCancel(shouldPin)) {
-                addPinnedCommand(finalArgs.join(" "));
-                p.log.success("Pinned! You can find it at the top of the main menu.");
-              }
-            }, 100);
+    }
+  }
+  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-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_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 runCommand = item.value;
+      const wasPinned = pinnedRunSet.has(runCommand);
+      togglePinnedRun(runCommand);
+      refreshPins();
+      setPinFeedback(
+        wasPinned ? `Unpinned exact run "${runCommand}"` : `Pinned exact run "${runCommand}"`
+      );
+    }
+  };
+  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: "green", 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: "cyan", bold: true, children: "?" }),
+      /* @__PURE__ */ jsx5(Text5, { children: label })
+    ] }),
+    /* @__PURE__ */ jsxs5(Box5, { gap: 1, marginLeft: 2, children: [
+      /* @__PURE__ */ jsx5(Text5, { color: "cyan", 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 runCommand = buildRunCommand(command, option.args);
+      const pinHint = pinnedRunSet.has(runCommand) ? "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: "cyan", 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: "cyan", bold: true, children: "Command" }),
+      /* @__PURE__ */ jsx6(Text6, { children: command })
+    ] }),
+    pinFeedback && /* @__PURE__ */ jsx6(Box6, { marginBottom: 1, children: /* @__PURE__ */ jsxs6(Text6, { color: "green", 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 runCommand = getRunCommandFromArgsSelection(
+              command,
+              value,
+              suggestions
+            );
+            if (runCommand) {
+              navigateWithExtraArgs(
+                runCommand.split(" ").slice(1).filter(Boolean)
+              );
+            }
+            return;
+          }
+        },
+        onRightAction: (item) => {
+          const runCommand = getRunCommandFromArgsSelection(
+            command,
+            item.value,
+            suggestions
+          );
+          if (!runCommand) {
+            return;
+          }
+          const wasPinned = pinnedRuns.includes(runCommand);
+          togglePinnedRun(runCommand);
+          setPinnedRuns2(getPinnedRuns());
+          setPinFeedback(
+            wasPinned ? `Unpinned exact run "${runCommand}"` : `Pinned exact run "${runCommand}"`
+          );
+        },
+        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((input, key) => {
+    if (key.upArrow || input === "k") {
+      setCursor((prev) => prev > 0 ? prev - 1 : flags.length - 1);
+    }
+    if (key.downArrow || input === "j") {
+      setCursor((prev) => prev < flags.length - 1 ? prev + 1 : 0);
+    }
+    if (input === " ") {
+      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);
         }
-        resolve();
+        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: "cyan", 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 ? "cyan" : void 0, children: isActive ? "\u276F" : " " }),
+        /* @__PURE__ */ jsx8(
+          Text7,
+          {
+            color: isChecked ? "green" : isActive ? "cyan" : void 0,
+            bold: isChecked,
+            children: isChecked ? "\u25C9" : "\u25CB"
+          }
+        ),
+        /* @__PURE__ */ jsx8(
+          Text7,
+          {
+            color: isActive ? "cyan" : 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 = "cyan"
+}) {
+  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((input) => {
+    if (input === "y" || input === "Y") {
+      onConfirm(true);
+    } else if (input === "n" || input === "N") {
+      onConfirm(false);
+    } else if (input === "\r") {
+      onConfirm(defaultValue);
+    }
+  });
+  return /* @__PURE__ */ jsxs11(Box10, { gap: 1, children: [
+    /* @__PURE__ */ jsx11(Text9, { color: "cyan", 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";
+async function runSupabaseCommand(args) {
+  return new Promise((resolve) => {
+    let stdout = "";
+    let stderr = "";
+    const child = spawn("supabase", args, {
+      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) => {
+      resolve({
+        exitCode: null,
+        signal: null,
+        stdout,
+        stderr,
+        spawnError: err.message
       });
     });
-    const next = await p.confirm({
-      message: "Do you want to run another command?",
-      initialValue: true
+    child.on("exit", (code, signal) => {
+      resolve({ exitCode: code, signal, stdout, stderr });
     });
-    if (!next || p.isCancel(next)) {
-      shouldExit = true;
+  });
+}
+
+// src/hooks/useCommand.ts
+function useCommand() {
+  const [status, setStatus] = useState7("idle");
+  const [result, setResult] = useState7(null);
+  const run = useCallback2(async (args) => {
+    setStatus("running");
+    setResult(null);
+    const res = await runSupabaseCommand(args);
+    setResult(res);
+    if (res.spawnError || res.exitCode !== null && res.exitCode !== 0) {
+      setStatus("error");
     } else {
-      console.clear();
-      p.intro(`${pc.bgGreen(pc.black(" POLTERBASE "))} Continue managing your Supabase project`);
+      setStatus("success");
+    }
+    return res;
+  }, []);
+  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((resolve) => {
+    const cmd = process.platform === "darwin" ? `open "${url}"` : process.platform === "win32" ? `start "${url}"` : `xdg-open "${url}"`;
+    exec(cmd, () => resolve());
+  });
+}
+async function copyToClipboard(text) {
+  return new Promise((resolve) => {
+    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", () => resolve());
+    child.on("error", () => resolve());
+  });
+}
+
+// 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 runCommand = currentArgs.join(" ");
+  useEffect4(() => {
+    if (phase === "running" && status === "idle") {
+      run(currentArgs);
     }
+  }, [phase, status, run, currentArgs]);
+  useEffect4(() => {
+    if (phase === "running" && status === "success") {
+      if (isPinnedRun(runCommand)) {
+        setPhase("success");
+      } else {
+        setPhase("success-pin-offer");
+      }
+    }
+    if (phase === "running" && status === "error") {
+      setPhase("error-menu");
+    }
+  }, [phase, runCommand, 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: "cyan", 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: "green", bold: true, children: "\u2713" }),
+        /* @__PURE__ */ jsx13(Text11, { color: "green", bold: true, children: "Command completed successfully!" })
+      ] }),
+      /* @__PURE__ */ jsx13(
+        ConfirmPrompt,
+        {
+          message: "Pin this exact command?",
+          defaultValue: false,
+          onConfirm: (shouldPin) => {
+            if (shouldPin && !isPinnedRun(runCommand)) {
+              togglePinnedRun(runCommand);
+              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: "green", bold: true, children: "\u2713" }),
+        /* @__PURE__ */ jsx13(Text11, { color: "green", bold: true, children: "Command completed successfully!" })
+      ] }),
+      pinMessage && /* @__PURE__ */ jsx13(Box12, { marginBottom: 1, children: /* @__PURE__ */ jsx13(Text11, { color: "green", 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 Polterbase" }
+  );
+  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: "yellow", bold: true, children: "\u{1F4A1} Supabase CLI not found in PATH" }),
+        /* @__PURE__ */ jsxs13(Box12, { gap: 1, children: [
+          /* @__PURE__ */ jsx13(Text11, { dimColor: true, children: "Install it:" }),
+          /* @__PURE__ */ jsx13(Text11, { color: "cyan", 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: "cyan", 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/app.tsx
+import { jsx as jsx14, jsxs as jsxs14 } from "react/jsx-runtime";
+function App() {
+  const { screen, params, navigate, goBack } = useNavigation();
+  const { exit } = useApp();
+  const handleExit = () => {
+    process.stdout.write(
+      "\n" + pc2.dim("Thank you for using ") + pc2.cyan(pc2.bold("Polterbase")) + pc2.dim("!") + "\n\n"
+    );
+    exit();
+  };
+  switch (screen) {
+    case "main-menu":
+      return /* @__PURE__ */ jsx14(MainMenu, { onNavigate: navigate, onExit: handleExit });
+    case "command-args":
+      return /* @__PURE__ */ jsx14(
+        CommandArgs,
+        {
+          command: params.command ?? "",
+          onNavigate: navigate,
+          onBack: goBack
+        }
+      );
+    case "custom-command":
+      return /* @__PURE__ */ jsx14(CustomCommand, { onNavigate: navigate, onBack: goBack });
+    case "flag-selection":
+      return /* @__PURE__ */ jsx14(
+        FlagSelection,
+        {
+          args: params.args ?? [],
+          onNavigate: navigate,
+          onBack: goBack
+        }
+      );
+    case "confirm-execute":
+    case "command-execution":
+      return /* @__PURE__ */ jsx14(
+        CommandExecution,
+        {
+          args: params.args ?? [],
+          onBack: goBack,
+          onExit: handleExit
+        }
+      );
+    default:
+      return /* @__PURE__ */ jsx14(Box13, { children: /* @__PURE__ */ jsxs14(Text12, { color: "red", children: [
+        "Unknown screen: ",
+        screen
+      ] }) });
   }
-  p.outro("Thank you for using Polterbase!");
 }
-main().catch(console.error);
+
+// src/index.tsx
+render(React7.createElement(App));