@polterware/polterbase 0.2.4 → 0.2.5

package/README.md

@@ -18,17 +18,30 @@ Polterbase is a productivity layer on top of the official `supabase` CLI. Instea
 - **Global Flags Picker**: Add common global flags in one step
 - **Pinned Commands and Runs**: Toggle base command pins with `→` and pin exact runs after success
 - **Custom Command Mode**: Run raw Supabase arguments like `-v` or `status -o json`
-- **Shell Execution**: Executes your local `supabase` binary directly
+- **Built-in Self-Update**: Update Polterbase for the current repository or globally through npm
+- **Shell Execution**: Resolves `supabase` from the current repository first, then falls back to `PATH`
 - **TypeScript-based CLI**: Strongly typed internal implementation
 
 ---
 
 ## Installation
 
-### Run without installing globally
+### Run one-off without installing
 
 ```bash
-npx @polterware/polterbase
+npx @polterware/polterbase@latest
+```
+
+### Install in a repository
+
+```bash
+npm install -D @polterware/polterbase
+```
+
+Then run it from that repository with:
+
+```bash
+npx polterbase
 ```
 
 ### Install globally
@@ -43,28 +56,36 @@ Then run:
 polterbase
 ```
 
-`polterbase` is a global CLI tool. Do not add it to `dependencies` or `devDependencies` of app projects.
+Use a repository install when you want the CLI version pinned to one project.
+Use a global install when you want the same CLI version across every repository.
 
 ### Update
 
-If you run Polterbase with `npx`, always use the latest published version explicitly:
+If you installed it globally, update it with:
 
 ```bash
-npx @polterware/polterbase@latest
+npm install -g @polterware/polterbase@latest
 ```
 
-If you installed it globally, update it with:
+If you installed it in a repository, update it there with:
 
 ```bash
-npm install -g @polterware/polterbase@latest
+npm install -D @polterware/polterbase@latest
 ```
 
+You can also run the same update flow from inside Polterbase:
+
+1. Go to the `Actions` section
+2. Choose `Update Polterbase`
+3. Choose `Current repository` or `Global install`
+4. Confirm the npm update command
+
 ---
 
 ## Requirements
 
 - **Node.js**: `>= 18`
-- **Supabase CLI**: installed and available in `PATH`
+- **Supabase CLI**: installed globally in `PATH` or locally in the current repository
 
 Check your environment:
 
@@ -83,12 +104,22 @@ Install Supabase CLI (official docs):
 
 ### Execution Model
 
-Polterbase always executes commands as:
+Polterbase executes workflow commands as:
 
 ```bash
 supabase <command> <extra-args> <global-flags>
 ```
 
+The self-update action is the only built-in exception and can run one of:
+
+```bash
+npm install -g @polterware/polterbase@latest
+```
+
+```bash
+npm install -D @polterware/polterbase@latest
+```
+
 ### Typical Flow
 
 1. Choose a command from the unified board
@@ -252,11 +283,11 @@ supabase db pull --yes
 
 ### `supabase: command not found`
 
-Supabase CLI is not installed or not in your `PATH`.
+Supabase CLI is not installed in the current repository and is not available in your `PATH`.
 
 Fix:
 
-1. Install Supabase CLI
+1. Install Supabase CLI globally or in the current repository
 2. Restart terminal
 3. Run `supabase --version`
 

package/dist/index.js

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 
 // src/index.tsx
-import React7 from "react";
+import React8 from "react";
 import { render } from "ink";
 
 // src/app.tsx
-import { Box as Box13, Text as Text12, useApp } from "ink";
+import { Box as Box14, Text as Text13, useApp } from "ink";
 
 // src/hooks/useNavigation.ts
 import { useState, useCallback } from "react";
@@ -446,17 +446,17 @@ function getPinnedRuns() {
 function setPinnedRuns(runs) {
   config.set(RUN_PINS_KEY, runs);
 }
-function togglePinnedRun(runCommand) {
+function togglePinnedRun(runCommand2) {
   ensurePinsInitialized();
   const current = getPinnedRuns();
-  if (current.includes(runCommand)) {
-    setPinnedRuns(current.filter((run) => run !== runCommand));
+  if (current.includes(runCommand2)) {
+    setPinnedRuns(current.filter((run) => run !== runCommand2));
     return;
   }
-  setPinnedRuns([runCommand, ...current.filter((run) => run !== runCommand)]);
+  setPinnedRuns([runCommand2, ...current.filter((run) => run !== runCommand2)]);
 }
-function isPinnedRun(runCommand) {
-  return getPinnedRuns().includes(runCommand);
+function isPinnedRun(runCommand2) {
+  return getPinnedRuns().includes(runCommand2);
 }
 
 // src/data/commands.ts
@@ -628,14 +628,14 @@ function buildMainMenuItems({
       kind: "header",
       selectable: false
     });
-    for (const runCommand of pinnedRuns) {
-      const baseCommand = runCommand.split(" ").filter(Boolean)[0] ?? "";
+    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:${runCommand}`,
-        value: runCommand,
-        label: runCommand,
+        id: `run:${runCommand2}`,
+        value: runCommand2,
+        label: runCommand2,
         hint: infoHint,
         icon: "\u25B6",
         kind: "run",
@@ -711,6 +711,14 @@ function buildMainMenuItems({
     icon: "\u270F\uFE0F",
     kind: "action"
   });
+  nextItems.push({
+    id: "action-update",
+    value: "__action_update__",
+    label: "Update Polterbase",
+    hint: "Update the current repo install or the global install",
+    icon: "\u2B06\uFE0F",
+    kind: "action"
+  });
   nextItems.push({
     id: "action-exit",
     value: "__action_exit__",
@@ -772,6 +780,10 @@ function MainMenu({
       onNavigate("custom-command");
       return;
     }
+    if (value === "__action_update__") {
+      onNavigate("self-update");
+      return;
+    }
     if (value === "__action_exit__") {
       onExit();
     }
@@ -788,12 +800,12 @@ function MainMenu({
       return;
     }
     if (item.kind === "run") {
-      const runCommand = item.value;
-      const wasPinned = pinnedRunSet.has(runCommand);
-      togglePinnedRun(runCommand);
+      const runCommand2 = item.value;
+      const wasPinned = pinnedRunSet.has(runCommand2);
+      togglePinnedRun(runCommand2);
       refreshPins();
       setPinFeedback(
-        wasPinned ? `Unpinned exact run "${runCommand}"` : `Pinned exact run "${runCommand}"`
+        wasPinned ? `Unpinned exact run "${runCommand2}"` : `Pinned exact run "${runCommand2}"`
       );
     }
   };
@@ -968,8 +980,8 @@ function buildCommandArgItems({
       selectable: false
     },
     ...suggestions.map((option) => {
-      const runCommand = buildRunCommand(command, option.args);
-      const pinHint = pinnedRunSet.has(runCommand) ? "pinned run" : void 0;
+      const runCommand2 = buildRunCommand(command, option.args);
+      const pinHint = pinnedRunSet.has(runCommand2) ? "pinned run" : void 0;
       return {
         value: `suggest:${option.value}`,
         label: option.label,
@@ -1110,33 +1122,33 @@ function CommandArgs({
             return;
           }
           if (value.startsWith("suggest:")) {
-            const runCommand = getRunCommandFromArgsSelection(
+            const runCommand2 = getRunCommandFromArgsSelection(
               command,
               value,
               suggestions
             );
-            if (runCommand) {
+            if (runCommand2) {
               navigateWithExtraArgs(
-                runCommand.split(" ").slice(1).filter(Boolean)
+                runCommand2.split(" ").slice(1).filter(Boolean)
               );
             }
             return;
           }
         },
         onRightAction: (item) => {
-          const runCommand = getRunCommandFromArgsSelection(
+          const runCommand2 = getRunCommandFromArgsSelection(
             command,
             item.value,
             suggestions
           );
-          if (!runCommand) {
+          if (!runCommand2) {
             return;
           }
-          const wasPinned = pinnedRuns.includes(runCommand);
-          togglePinnedRun(runCommand);
+          const wasPinned = pinnedRuns.includes(runCommand2);
+          togglePinnedRun(runCommand2);
           setPinnedRuns2(getPinnedRuns());
           setPinFeedback(
-            wasPinned ? `Unpinned exact run "${runCommand}"` : `Pinned exact run "${runCommand}"`
+            wasPinned ? `Unpinned exact run "${runCommand2}"` : `Pinned exact run "${runCommand2}"`
           );
         },
         onCancel: onBack,
@@ -1358,11 +1370,65 @@ 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) => {
+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((resolve3) => {
     let stdout = "";
     let stderr = "";
-    const child = spawn("supabase", args, {
+    const resolvedExecution = typeof execution === "string" ? { command: execution } : execution;
+    const child = spawn(resolvedExecution.command, args, {
+      cwd,
+      env: resolvedExecution.env,
       shell: true,
       stdio: ["inherit", "pipe", "pipe"]
     });
@@ -1377,7 +1443,7 @@ async function runSupabaseCommand(args) {
       process.stderr.write(text);
     });
     child.on("error", (err) => {
-      resolve({
+      resolve3({
         exitCode: null,
         signal: null,
         stdout,
@@ -1386,19 +1452,22 @@ async function runSupabaseCommand(args) {
       });
     });
     child.on("exit", (code, signal) => {
-      resolve({ exitCode: code, signal, stdout, stderr });
+      resolve3({ exitCode: code, signal, stdout, stderr });
     });
   });
 }
+async function runSupabaseCommand(args, cwd = process.cwd()) {
+  return runCommand(resolveSupabaseCommand(cwd), args, cwd);
+}
 
 // src/hooks/useCommand.ts
-function useCommand() {
+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 = await runSupabaseCommand(args);
+    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");
@@ -1406,7 +1475,7 @@ function useCommand() {
       setStatus("success");
     }
     return res;
-  }, []);
+  }, [cwd, execution]);
   const reset = useCallback2(() => {
     setStatus("idle");
     setResult(null);
@@ -1417,19 +1486,19 @@ function useCommand() {
 // src/lib/clipboard.ts
 import { spawn as spawn2, exec } from "child_process";
 async function openInBrowser(url) {
-  return new Promise((resolve) => {
+  return new Promise((resolve3) => {
     const cmd = process.platform === "darwin" ? `open "${url}"` : process.platform === "win32" ? `start "${url}"` : `xdg-open "${url}"`;
-    exec(cmd, () => resolve());
+    exec(cmd, () => resolve3());
   });
 }
 async function copyToClipboard(text) {
-  return new Promise((resolve) => {
+  return new Promise((resolve3) => {
     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());
+    child.on("exit", () => resolve3());
+    child.on("error", () => resolve3());
   });
 }
 
@@ -1445,7 +1514,7 @@ function CommandExecution({
   const [pinMessage, setPinMessage] = useState8();
   const { status, result, run, reset } = useCommand();
   const cmdDisplay = `supabase ${currentArgs.join(" ")}`;
-  const runCommand = currentArgs.join(" ");
+  const runCommand2 = currentArgs.join(" ");
   useEffect4(() => {
     if (phase === "running" && status === "idle") {
       run(currentArgs);
@@ -1453,7 +1522,7 @@ function CommandExecution({
   }, [phase, status, run, currentArgs]);
   useEffect4(() => {
     if (phase === "running" && status === "success") {
-      if (isPinnedRun(runCommand)) {
+      if (isPinnedRun(runCommand2)) {
         setPhase("success");
       } else {
         setPhase("success-pin-offer");
@@ -1462,7 +1531,7 @@ function CommandExecution({
     if (phase === "running" && status === "error") {
       setPhase("error-menu");
     }
-  }, [phase, runCommand, status]);
+  }, [phase, runCommand2, status]);
   if (phase === "confirm") {
     return /* @__PURE__ */ jsx13(Box12, { flexDirection: "column", children: /* @__PURE__ */ jsx13(
       ConfirmPrompt,
@@ -1504,8 +1573,8 @@ function CommandExecution({
           message: "Pin this exact command?",
           defaultValue: false,
           onConfirm: (shouldPin) => {
-            if (shouldPin && !isPinnedRun(runCommand)) {
-              togglePinnedRun(runCommand);
+            if (shouldPin && !isPinnedRun(runCommand2)) {
+              togglePinnedRun(runCommand2);
               setPinMessage("Exact command pinned to Pinned Runs.");
             }
             setPhase("success");
@@ -1569,7 +1638,7 @@ function CommandExecution({
         /* @__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 PATH" }),
+        /* @__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" })
@@ -1634,8 +1703,244 @@ function CommandExecution({
   ] });
 }
 
-// src/app.tsx
+// 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/polterbase";
+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 Polterbase." }) }),
+      /* @__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 Polterbase..." }) })
+    ] });
+  }
+  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 Polterbase 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 Polterbase" }
+          ],
+          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 Polterbase" }
+        ],
+        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();
@@ -1647,9 +1952,9 @@ function App() {
   };
   switch (screen) {
     case "main-menu":
-      return /* @__PURE__ */ jsx14(MainMenu, { onNavigate: navigate, onExit: handleExit });
+      return /* @__PURE__ */ jsx15(MainMenu, { onNavigate: navigate, onExit: handleExit });
     case "command-args":
-      return /* @__PURE__ */ jsx14(
+      return /* @__PURE__ */ jsx15(
         CommandArgs,
         {
           command: params.command ?? "",
@@ -1658,9 +1963,9 @@ function App() {
         }
       );
     case "custom-command":
-      return /* @__PURE__ */ jsx14(CustomCommand, { onNavigate: navigate, onBack: goBack });
+      return /* @__PURE__ */ jsx15(CustomCommand, { onNavigate: navigate, onBack: goBack });
     case "flag-selection":
-      return /* @__PURE__ */ jsx14(
+      return /* @__PURE__ */ jsx15(
         FlagSelection,
         {
           args: params.args ?? [],
@@ -1670,7 +1975,7 @@ function App() {
       );
     case "confirm-execute":
     case "command-execution":
-      return /* @__PURE__ */ jsx14(
+      return /* @__PURE__ */ jsx15(
         CommandExecution,
         {
           args: params.args ?? [],
@@ -1678,8 +1983,10 @@ function App() {
           onExit: handleExit
         }
       );
+    case "self-update":
+      return /* @__PURE__ */ jsx15(SelfUpdate, { onBack: goBack, onExit: handleExit });
     default:
-      return /* @__PURE__ */ jsx14(Box13, { children: /* @__PURE__ */ jsxs14(Text12, { color: "red", children: [
+      return /* @__PURE__ */ jsx15(Box14, { children: /* @__PURE__ */ jsxs15(Text13, { color: "red", children: [
         "Unknown screen: ",
         screen
       ] }) });
@@ -1687,4 +1994,4 @@ function App() {
 }
 
 // src/index.tsx
-render(React7.createElement(App));
+render(React8.createElement(App));

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@polterware/polterbase",
-  "version": "0.2.4",
-  "description": "A global CLI for managing Supabase CLI workflows.",
+  "version": "0.2.5",
+  "description": "An interactive CLI for managing Supabase CLI workflows.",
   "type": "module",
   "bin": {
     "polterbase": "./dist/index.js"
@@ -22,7 +22,6 @@
   "publishConfig": {
     "access": "public"
   },
-  "preferGlobal": true,
   "scripts": {
     "dev": "tsup src/index.tsx --watch --format esm --dts",
     "build": "tsup src/index.tsx --format esm --clean",