@polterware/polterbase 0.2.4 → 0.2.6

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";
@@ -43,7 +43,7 @@ var SUPABASE_FG = "\x1B[38;2;62;207;142m";
 var SUPABASE_BG = "\x1B[48;2;62;207;142m";
 var RESET_FG = "\x1B[39m";
 var RESET_BG = "\x1B[49m";
-var wrapAnsi = (open, close) => (input) => pc.isColorSupported ? `${open}${input}${close}` : input;
+var wrapAnsi = (open, close) => (input2) => pc.isColorSupported ? `${open}${input2}${close}` : input2;
 var supabase = wrapAnsi(SUPABASE_FG, RESET_FG);
 var supabaseBg = wrapAnsi(SUPABASE_BG, RESET_BG);
 var VERSION = packageJson.version;
@@ -229,21 +229,21 @@ function SelectList({
   }, [selectableIndexes]);
   const selectedItemIndex = selectableIndexes[selectedSelectableIndex] ?? -1;
   const selectedItem = selectedItemIndex >= 0 ? items[selectedItemIndex] : void 0;
-  useInput((input, key) => {
+  useInput((input2, key) => {
     if (selectableIndexes.length === 0) {
       if (key.escape && onCancel) {
         onCancel();
       }
       return;
     }
-    if (key.upArrow || input === "k") {
+    if (key.upArrow || input2 === "k") {
       setSelectedSelectableIndex((prev) => {
         let next = prev - 1;
         if (next < 0) next = selectableIndexes.length - 1;
         return next;
       });
     }
-    if (key.downArrow || input === "j") {
+    if (key.downArrow || input2 === "j") {
       setSelectedSelectableIndex((prev) => {
         let next = prev + 1;
         if (next >= selectableIndexes.length) next = 0;
@@ -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,
@@ -1189,14 +1201,14 @@ function FlagToggle({
 }) {
   const [cursor, setCursor] = useState6(0);
   const [selected, setSelected] = useState6(/* @__PURE__ */ new Set());
-  useInput3((input, key) => {
-    if (key.upArrow || input === "k") {
+  useInput3((input2, key) => {
+    if (key.upArrow || input2 === "k") {
       setCursor((prev) => prev > 0 ? prev - 1 : flags.length - 1);
     }
-    if (key.downArrow || input === "j") {
+    if (key.downArrow || input2 === "j") {
       setCursor((prev) => prev < flags.length - 1 ? prev + 1 : 0);
     }
-    if (input === " ") {
+    if (input2 === " ") {
       setSelected((prev) => {
         const next = new Set(prev);
         const flag = flags[cursor];
@@ -1314,12 +1326,12 @@ function ConfirmPrompt({
   defaultValue = true,
   onConfirm
 }) {
-  useInput4((input) => {
-    if (input === "y" || input === "Y") {
+  useInput4((input2) => {
+    if (input2 === "y" || input2 === "Y") {
       onConfirm(true);
-    } else if (input === "n" || input === "N") {
+    } else if (input2 === "n" || input2 === "N") {
       onConfirm(false);
-    } else if (input === "\r") {
+    } else if (input2 === "\r") {
       onConfirm(defaultValue);
     }
   });
@@ -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((resolve4) => {
     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({
+      resolve4({
         exitCode: null,
         signal: null,
         stdout,
@@ -1386,19 +1452,22 @@ async function runSupabaseCommand(args) {
       });
     });
     child.on("exit", (code, signal) => {
-      resolve({ exitCode: code, signal, stdout, stderr });
+      resolve4({ exitCode: code, signal, stdout, stderr });
     });
   });
 }
+async function runSupabaseCommand(args, cwd = process.cwd()) {
+  return runCommand(resolveSupabaseCommand(cwd), args, cwd);
+}
 
 // src/hooks/useCommand.ts
-function useCommand() {
+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((resolve4) => {
     const cmd = process.platform === "darwin" ? `open "${url}"` : process.platform === "win32" ? `start "${url}"` : `xdg-open "${url}"`;
-    exec(cmd, () => resolve());
+    exec(cmd, () => resolve4());
   });
 }
 async function copyToClipboard(text) {
-  return new Promise((resolve) => {
+  return new Promise((resolve4) => {
     const cmd = process.platform === "darwin" ? "pbcopy" : process.platform === "win32" ? "clip" : "xclip -selection clipboard";
     const child = spawn2(cmd, [], { shell: true });
     child.stdin?.write(text);
     child.stdin?.end();
-    child.on("exit", () => resolve());
-    child.on("error", () => resolve());
+    child.on("exit", () => resolve4());
+    child.on("error", () => resolve4());
   });
 }
 
@@ -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,13 +1983,930 @@ 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
       ] }) });
   }
 }
 
+// src/lib/cliArgs.ts
+function takeValue(args, index) {
+  const token = args[index];
+  if (!token) {
+    return { nextIndex: index };
+  }
+  const eqIndex = token.indexOf("=");
+  if (eqIndex >= 0) {
+    return {
+      value: token.slice(eqIndex + 1),
+      nextIndex: index
+    };
+  }
+  return { value: args[index + 1], nextIndex: index + 1 };
+}
+function parseCliArgs(argv) {
+  if (argv.length === 0) {
+    return { mode: "interactive", options: {} };
+  }
+  if (argv[0] === "--help" || argv[0] === "help") {
+    return { mode: "help", options: {} };
+  }
+  if (argv[0] !== "app") {
+    return { mode: "interactive", options: {} };
+  }
+  const options = {};
+  options.action = argv[1];
+  options.app = argv[2];
+  for (let index = 3; index < argv.length; index += 1) {
+    const token = argv[index];
+    if (token === "push" || token === "lint" || token === "reset" || token === "local-reset") {
+      options.migrationAction = token;
+      continue;
+    }
+    if (token === "--yes") {
+      options.yes = true;
+      continue;
+    }
+    if (token === "--relink") {
+      options.relink = true;
+      continue;
+    }
+    if (token === "--create-project") {
+      options.createProject = true;
+      continue;
+    }
+    if (token === "--use-existing-project") {
+      options.useExistingProject = true;
+      continue;
+    }
+    if (token.startsWith("--path")) {
+      const parsed = takeValue(argv, index);
+      options.path = parsed.value;
+      index = parsed.nextIndex;
+      continue;
+    }
+    if (token.startsWith("--platform")) {
+      const parsed = takeValue(argv, index);
+      options.platform = parsed.value;
+      index = parsed.nextIndex;
+      continue;
+    }
+    if (token.startsWith("--version")) {
+      const parsed = takeValue(argv, index);
+      options.version = parsed.value;
+      index = parsed.nextIndex;
+      continue;
+    }
+    if (token.startsWith("--artifact-url")) {
+      const parsed = takeValue(argv, index);
+      options.artifactUrl = parsed.value;
+      index = parsed.nextIndex;
+      continue;
+    }
+    if (token.startsWith("--install-dir")) {
+      const parsed = takeValue(argv, index);
+      options.installDir = parsed.value;
+      index = parsed.nextIndex;
+      continue;
+    }
+  }
+  return {
+    mode: "app",
+    options
+  };
+}
+function printCliHelp() {
+  process.stdout.write(
+    [
+      "Polterbase",
+      "",
+      "Usage:",
+      "  polterbase",
+      "  polterbase app setup uru [--path <dir>] [--create-project|--use-existing-project] [--yes]",
+      "  polterbase app link uru [--path <dir>] [--relink]",
+      "  polterbase app migrate uru [push|lint|reset|local-reset] [--path <dir>] [--relink]",
+      "  polterbase app configure uru [--path <dir>] [--yes]",
+      "  polterbase app install uru --platform macos [--version <version>] [--artifact-url <url>] [--install-dir <dir>] [--yes]",
+      "",
+      "Notes:",
+      "  - App workflows stay separate from the generic Supabase interactive menu.",
+      "  - `install uru` resolves the latest GitHub release from polterware/uru by default.",
+      "  - Use --artifact-url or POLTERBASE_URU_MACOS_ARTIFACT_URL to override the downloaded asset.",
+      "  - Use POLTERBASE_URU_GITHUB_REPO=owner/repo to resolve releases from a different repository.",
+      ""
+    ].join("\n")
+  );
+}
+
+// src/apps/runAppCli.ts
+import pc3 from "picocolors";
+
+// src/apps/uru.ts
+import { existsSync as existsSync3, mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
+import { mkdtemp, readdir, stat } from "fs/promises";
+import { dirname as dirname3, join as join4, resolve as resolve3 } from "path";
+import { tmpdir } from "os";
+import pc2 from "picocolors";
+
+// src/apps/bootstrapPaths.ts
+import { homedir } from "os";
+import { join as join3 } from "path";
+function getUruBootstrapPayloadPath() {
+  const home = homedir();
+  if (process.platform === "darwin") {
+    return join3(
+      home,
+      "Library",
+      "Application Support",
+      "uru",
+      "bootstrap",
+      "supabase.json"
+    );
+  }
+  if (process.platform === "win32") {
+    const appData = process.env.APPDATA ?? join3(home, "AppData", "Roaming");
+    return join3(appData, "uru", "bootstrap", "supabase.json");
+  }
+  return join3(home, ".config", "uru", "bootstrap", "supabase.json");
+}
+
+// src/apps/uruRelease.ts
+var DEFAULT_URU_GITHUB_REPO = "polterware/uru";
+var DEFAULT_ARTIFACT_ENV_VAR = "POLTERBASE_URU_MACOS_ARTIFACT_URL";
+var DEFAULT_GITHUB_REPO_ENV_VAR = "POLTERBASE_URU_GITHUB_REPO";
+var GITHUB_API_BASE = "https://api.github.com/repos";
+function getGitHubHeaders(env) {
+  const headers = {
+    Accept: "application/vnd.github+json",
+    "X-GitHub-Api-Version": "2022-11-28"
+  };
+  const token = env.GITHUB_TOKEN?.trim() || env.GH_TOKEN?.trim();
+  if (token) {
+    headers.Authorization = `Bearer ${token}`;
+  }
+  return headers;
+}
+function getGitHubReleaseRequestLabel(repo, version) {
+  if (!version) {
+    return `latest release in ${repo}`;
+  }
+  return `release ${version} in ${repo}`;
+}
+function parseGitHubReleaseAsset(value) {
+  if (!value || typeof value !== "object") {
+    return null;
+  }
+  const asset = value;
+  const name = typeof asset.name === "string" ? asset.name.trim() : "";
+  const browserDownloadUrl = typeof asset.browser_download_url === "string" ? asset.browser_download_url.trim() : "";
+  const size = typeof asset.size === "number" ? asset.size : void 0;
+  if (!name || !browserDownloadUrl) {
+    return null;
+  }
+  return {
+    name,
+    browserDownloadUrl,
+    size
+  };
+}
+async function parseGitHubReleaseResponse(response, label) {
+  const body = await response.text();
+  if (!response.ok) {
+    let detail = body.trim();
+    try {
+      const parsed2 = JSON.parse(body);
+      if (typeof parsed2.message === "string" && parsed2.message.trim()) {
+        detail = parsed2.message.trim();
+      }
+    } catch {
+    }
+    throw new Error(
+      `Unable to resolve ${label}: ${response.status} ${response.statusText}${detail ? ` (${detail})` : ""}.`
+    );
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(body);
+  } catch (error) {
+    throw new Error(
+      `Unable to parse ${label} from GitHub: ${error instanceof Error ? error.message : String(error)}.`
+    );
+  }
+  const assets = Array.isArray(parsed.assets) ? parsed.assets.map((asset) => parseGitHubReleaseAsset(asset)).filter((asset) => asset !== null) : [];
+  if (assets.length === 0) {
+    throw new Error(`GitHub ${label} did not contain any downloadable assets.`);
+  }
+  return {
+    tagName: typeof parsed.tag_name === "string" ? parsed.tag_name : null,
+    assets
+  };
+}
+function normalizeUruReleaseVersion(version) {
+  return version.trim().replace(/^v/i, "");
+}
+function buildVersionTagCandidates(version) {
+  const normalized = normalizeUruReleaseVersion(version);
+  if (!normalized) {
+    return [];
+  }
+  return Array.from(/* @__PURE__ */ new Set([`v${normalized}`, normalized]));
+}
+async function fetchGitHubRelease(repo, version, fetchImpl, env) {
+  const headers = getGitHubHeaders(env);
+  if (version) {
+    const tagCandidates = buildVersionTagCandidates(version);
+    for (const tag of tagCandidates) {
+      const response2 = await fetchImpl(
+        `${GITHUB_API_BASE}/${repo}/releases/tags/${encodeURIComponent(tag)}`,
+        { headers }
+      );
+      if (response2.status === 404) {
+        continue;
+      }
+      return parseGitHubReleaseResponse(
+        response2,
+        getGitHubReleaseRequestLabel(repo, tag)
+      );
+    }
+    throw new Error(
+      `Unable to find release ${normalizeUruReleaseVersion(version)} in ${repo}.`
+    );
+  }
+  const response = await fetchImpl(`${GITHUB_API_BASE}/${repo}/releases/latest`, {
+    headers
+  });
+  return parseGitHubReleaseResponse(
+    response,
+    getGitHubReleaseRequestLabel(repo)
+  );
+}
+function getArtifactFileNameFromUrl(url, fallback = "uru-macos.zip") {
+  try {
+    const pathname = new URL(url).pathname;
+    const name = decodeURIComponent(pathname.split("/").pop() ?? "").trim();
+    return name || fallback;
+  } catch {
+    const name = decodeURIComponent(url.split("?")[0]?.split("/").pop() ?? "").trim();
+    return name || fallback;
+  }
+}
+function hasSupportedArchiveFormat(name) {
+  const lowered = name.toLowerCase();
+  return lowered.endsWith(".app.tar.gz") || lowered.endsWith(".zip");
+}
+function hasMacosHint(name) {
+  const lowered = name.toLowerCase();
+  return lowered.endsWith(".app.tar.gz") || lowered.includes(".app.zip") || lowered.includes("macos") || lowered.includes("darwin") || lowered.includes("universal");
+}
+function isSupportedUruMacosArtifactName(name) {
+  return hasSupportedArchiveFormat(name) && hasMacosHint(name);
+}
+function getArchAliases(arch) {
+  switch (arch) {
+    case "arm64":
+    case "aarch64":
+      return ["arm64", "aarch64"];
+    case "x64":
+    case "x86_64":
+    case "amd64":
+      return ["x64", "x86_64", "amd64"];
+    default:
+      return [arch.toLowerCase()];
+  }
+}
+function hasAnyArchHint(name) {
+  return /(arm64|aarch64|x64|x86_64|amd64)/.test(name.toLowerCase());
+}
+function getArchPriority(name, arch) {
+  const lowered = name.toLowerCase();
+  if (lowered.includes("universal")) {
+    return 0;
+  }
+  const aliases = getArchAliases(arch);
+  if (aliases.some((alias) => lowered.includes(alias))) {
+    return 1;
+  }
+  if (hasAnyArchHint(lowered)) {
+    return 3;
+  }
+  return 2;
+}
+function getFormatPriority(name) {
+  return name.toLowerCase().endsWith(".app.tar.gz") ? 0 : 1;
+}
+function selectUruMacosReleaseAsset(assets, arch = process.arch) {
+  const supported = assets.map((asset, index) => ({ asset, index })).filter(({ asset }) => isSupportedUruMacosArtifactName(asset.name)).sort((left, right) => {
+    const archPriority = getArchPriority(left.asset.name, arch) - getArchPriority(right.asset.name, arch);
+    if (archPriority !== 0) {
+      return archPriority;
+    }
+    const formatPriority = getFormatPriority(left.asset.name) - getFormatPriority(right.asset.name);
+    if (formatPriority !== 0) {
+      return formatPriority;
+    }
+    return left.index - right.index;
+  });
+  if (supported.length === 0) {
+    const names = assets.map((asset) => asset.name).join(", ");
+    throw new Error(
+      `No supported macOS archive was found in the release. Expected a .app.tar.gz or .zip asset for macOS, found: ${names}.`
+    );
+  }
+  return supported[0].asset;
+}
+async function resolveUruMacosArtifact(options, env = process.env, fetchImpl = fetch, arch = process.arch) {
+  const explicitUrl = options.artifactUrl?.trim() || env[DEFAULT_ARTIFACT_ENV_VAR]?.trim();
+  if (explicitUrl) {
+    return {
+      url: explicitUrl,
+      fileName: getArtifactFileNameFromUrl(explicitUrl),
+      source: "explicit-url"
+    };
+  }
+  const repo = env[DEFAULT_GITHUB_REPO_ENV_VAR]?.trim() || DEFAULT_URU_GITHUB_REPO;
+  const release = await fetchGitHubRelease(repo, options.version, fetchImpl, env);
+  const asset = selectUruMacosReleaseAsset(release.assets, arch);
+  return {
+    url: asset.browserDownloadUrl,
+    fileName: asset.name,
+    size: asset.size,
+    source: "github-release",
+    repo,
+    tagName: release.tagName
+  };
+}
+
+// src/lib/prompts.ts
+import { createInterface } from "readline/promises";
+import { stdin as input, stdout as output } from "process";
+async function promptText(label, options = {}) {
+  const rl = createInterface({ input, output });
+  try {
+    while (true) {
+      const suffix = options.defaultValue ? ` (${options.defaultValue})` : "";
+      const answer = (await rl.question(`${label}${suffix}: `)).trim();
+      if (!answer && options.defaultValue) {
+        return options.defaultValue;
+      }
+      if (!answer && options.required) {
+        output.write("This value is required.\n");
+        continue;
+      }
+      return answer;
+    }
+  } finally {
+    rl.close();
+  }
+}
+async function promptConfirm(label, defaultValue = true) {
+  const rl = createInterface({ input, output });
+  try {
+    const answer = (await rl.question(`${label} ${defaultValue ? "(Y/n)" : "(y/N)"}: `)).trim().toLowerCase();
+    if (!answer) {
+      return defaultValue;
+    }
+    return answer === "y" || answer === "yes";
+  } finally {
+    rl.close();
+  }
+}
+async function promptSelect(label, options, defaultValue) {
+  const rl = createInterface({ input, output });
+  try {
+    output.write(`${label}
+`);
+    for (const [index, option] of options.entries()) {
+      const marker = option.value === defaultValue ? " (default)" : "";
+      output.write(`  ${index + 1}. ${option.label}${marker}
+`);
+    }
+    while (true) {
+      const answer = (await rl.question(
+        `Choose 1-${options.length}${defaultValue ? " (press Enter for default)" : ""}: `
+      )).trim();
+      if (!answer && defaultValue) {
+        return defaultValue;
+      }
+      const selectedIndex = Number(answer);
+      if (Number.isInteger(selectedIndex) && selectedIndex >= 1 && selectedIndex <= options.length) {
+        return options[selectedIndex - 1].value;
+      }
+      output.write("Invalid selection.\n");
+    }
+  } finally {
+    rl.close();
+  }
+}
+
+// src/lib/system.ts
+import { execSync } from "child_process";
+function commandExists(command) {
+  try {
+    execSync(`command -v ${command}`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/apps/uru.ts
+var LINK_REF_FILE = join4("supabase", ".temp", "project-ref");
+function isUruProjectRoot(candidate) {
+  return existsSync3(join4(candidate, "src-tauri", "tauri.conf.json")) && existsSync3(join4(candidate, "supabase", "migrations")) && existsSync3(join4(candidate, "package.json"));
+}
+function findNearestUruRoot(startDir) {
+  let currentDir = resolve3(startDir);
+  while (true) {
+    if (isUruProjectRoot(currentDir)) {
+      return currentDir;
+    }
+    const siblingCandidate = join4(currentDir, "uru");
+    if (isUruProjectRoot(siblingCandidate)) {
+      return siblingCandidate;
+    }
+    const parentDir = dirname3(currentDir);
+    if (parentDir === currentDir) {
+      return void 0;
+    }
+    currentDir = parentDir;
+  }
+}
+function readEnvFile(envPath) {
+  if (!existsSync3(envPath)) {
+    return {};
+  }
+  const content = readFileSync(envPath, "utf-8");
+  const entries = {};
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) {
+      continue;
+    }
+    const eqIndex = trimmed.indexOf("=");
+    if (eqIndex === -1) {
+      continue;
+    }
+    const key = trimmed.slice(0, eqIndex).trim();
+    const value = trimmed.slice(eqIndex + 1).trim();
+    entries[key] = value;
+  }
+  return entries;
+}
+function writeEnvFile(envPath, nextEnv) {
+  const content = Object.entries(nextEnv).map(([key, value]) => `${key}=${value}`).join("\n");
+  writeFileSync(envPath, `${content}
+`);
+}
+function assertProjectRoot(projectRoot) {
+  if (!projectRoot) {
+    throw new Error(
+      "Could not resolve the Uru project root. Run from the Uru repository or pass --path."
+    );
+  }
+  return projectRoot;
+}
+function getLinkedProjectRef(projectRoot) {
+  const refPath = join4(projectRoot, LINK_REF_FILE);
+  if (!existsSync3(refPath)) {
+    return null;
+  }
+  const value = readFileSync(refPath, "utf-8").trim();
+  return value || null;
+}
+function getDbPasswordArgs() {
+  const password = process.env.SUPABASE_DB_PASSWORD?.trim();
+  return password ? ["--password", password] : [];
+}
+async function ensurePrerequisites() {
+  const checks = [
+    { command: "node", label: "Node.js" },
+    { command: "pnpm", label: "pnpm" },
+    { command: "supabase", label: "Supabase CLI" }
+  ];
+  const missing = checks.filter((check) => !commandExists(check.command));
+  if (missing.length > 0) {
+    throw new Error(
+      `Missing required tools: ${missing.map((item) => item.label).join(", ")}`
+    );
+  }
+}
+async function runOrThrow(execution, args, cwd, failureMessage) {
+  const result = await runCommand(execution, args, cwd);
+  if (result.spawnError || result.exitCode !== 0) {
+    throw new Error(
+      result.stderr.trim() || result.spawnError || failureMessage
+    );
+  }
+}
+async function runSupabaseOrThrow(args, cwd, failureMessage) {
+  const result = await runSupabaseCommand(args, cwd);
+  if (result.spawnError || result.exitCode !== 0) {
+    throw new Error(
+      result.stderr.trim() || result.spawnError || failureMessage
+    );
+  }
+}
+async function ensureSupabaseLink(projectRoot, forceRelink = false) {
+  const linkedRef = getLinkedProjectRef(projectRoot);
+  if (linkedRef && !forceRelink) {
+    process.stdout.write(`${pc2.dim(`Linked project: ${linkedRef}`)}
+`);
+    return;
+  }
+  process.stdout.write(
+    `${pc2.dim(forceRelink ? "Relinking Supabase project..." : "Linking Supabase project...")}
+`
+  );
+  await runSupabaseOrThrow(
+    ["link", ...getDbPasswordArgs()],
+    projectRoot,
+    "Supabase link failed."
+  );
+}
+async function collectSupabaseConfig(projectRoot) {
+  const envPath = projectRoot ? join4(projectRoot, ".env.local") : void 0;
+  const currentEnv = envPath ? readEnvFile(envPath) : {};
+  const currentRef = projectRoot ? getLinkedProjectRef(projectRoot) : null;
+  const url = await promptText("Supabase URL", {
+    defaultValue: currentEnv.VITE_SUPABASE_URL,
+    required: true
+  });
+  const publishableKey = await promptText("Supabase publishable key", {
+    defaultValue: currentEnv.VITE_SUPABASE_PUBLISHABLE_DEFAULT_KEY,
+    required: true
+  });
+  const projectRef = await promptText("Supabase project ref", {
+    defaultValue: currentRef ?? "",
+    required: true
+  });
+  return {
+    url: url.trim().replace(/\/$/, ""),
+    publishableKey: publishableKey.trim(),
+    projectRef: projectRef.trim()
+  };
+}
+function writeUruEnv(projectRoot, config2) {
+  const envPath = join4(projectRoot, ".env.local");
+  const currentEnv = readEnvFile(envPath);
+  const nextEnv = {
+    ...currentEnv,
+    VITE_SUPABASE_URL: config2.url,
+    VITE_SUPABASE_PUBLISHABLE_DEFAULT_KEY: config2.publishableKey
+  };
+  writeEnvFile(envPath, nextEnv);
+}
+function writeBootstrapPayload(config2) {
+  const payloadPath = getUruBootstrapPayloadPath();
+  mkdirSync(dirname3(payloadPath), { recursive: true });
+  writeFileSync(
+    payloadPath,
+    JSON.stringify(
+      {
+        url: config2.url,
+        publishableKey: config2.publishableKey,
+        projectRef: config2.projectRef,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        source: "polterbase"
+      },
+      null,
+      2
+    )
+  );
+  return payloadPath;
+}
+async function promptProjectMode(options) {
+  if (options.useExistingProject) {
+    return "existing";
+  }
+  if (options.createProject) {
+    return "create";
+  }
+  const selected = await promptSelect(
+    "How should Polterbase prepare Supabase for Uru?",
+    [
+      { value: "existing", label: "Use an existing Supabase project" },
+      { value: "create", label: "Create a new Supabase project first" }
+    ],
+    "existing"
+  );
+  return selected;
+}
+async function runSetup(context) {
+  const projectRoot = assertProjectRoot(context.projectRoot);
+  await ensurePrerequisites();
+  const mode = await promptProjectMode(context.options);
+  if (mode === "create") {
+    process.stdout.write(
+      `${pc2.dim("Launching interactive Supabase project creation...")}
+`
+    );
+    await runSupabaseOrThrow(
+      ["projects", "create"],
+      projectRoot,
+      "Supabase project creation failed."
+    );
+  }
+  const config2 = await collectSupabaseConfig(projectRoot);
+  writeUruEnv(projectRoot, config2);
+  process.stdout.write(`${pc2.green("Saved .env.local")}
+`);
+  process.stdout.write(`${pc2.dim("Installing project dependencies...")}
+`);
+  await runOrThrow(
+    "pnpm",
+    ["install", "--frozen-lockfile"],
+    projectRoot,
+    "Dependency installation failed."
+  );
+  await ensureSupabaseLink(projectRoot, context.options.relink);
+  process.stdout.write(`${pc2.dim("Pushing migrations to linked project...")}
+`);
+  await runSupabaseOrThrow(
+    ["db", "push", "--linked", ...getDbPasswordArgs()],
+    projectRoot,
+    "Migration push failed."
+  );
+  const payloadPath = writeBootstrapPayload(config2);
+  process.stdout.write(`${pc2.green("Prepared runtime bootstrap payload")}
+`);
+  process.stdout.write(`${pc2.dim(`Payload path: ${payloadPath}`)}
+`);
+  return 0;
+}
+async function runLink(context) {
+  const projectRoot = assertProjectRoot(context.projectRoot);
+  await ensurePrerequisites();
+  await ensureSupabaseLink(projectRoot, true);
+  process.stdout.write(`${pc2.green("Supabase link completed")}
+`);
+  return 0;
+}
+async function runMigration(context, action) {
+  const projectRoot = assertProjectRoot(context.projectRoot);
+  await ensurePrerequisites();
+  switch (action) {
+    case "local-reset":
+      await runSupabaseOrThrow(
+        ["db", "reset", "--local"],
+        projectRoot,
+        "Local reset failed."
+      );
+      process.stdout.write(`${pc2.green("Local Supabase reset completed")}
+`);
+      return 0;
+    case "push":
+      await ensureSupabaseLink(projectRoot, context.options.relink);
+      await runSupabaseOrThrow(
+        ["db", "push", "--linked", ...getDbPasswordArgs()],
+        projectRoot,
+        "Migration push failed."
+      );
+      process.stdout.write(`${pc2.green("Migrations pushed")}
+`);
+      return 0;
+    case "lint":
+      await ensureSupabaseLink(projectRoot, context.options.relink);
+      await runSupabaseOrThrow(
+        ["db", "lint", "--linked"],
+        projectRoot,
+        "Migration lint failed."
+      );
+      process.stdout.write(`${pc2.green("Migration lint completed")}
+`);
+      return 0;
+    case "reset":
+      await ensureSupabaseLink(projectRoot, context.options.relink);
+      if (!context.options.yes) {
+        const confirmed = await promptConfirm(
+          "This will reset the linked remote database. Continue?",
+          false
+        );
+        if (!confirmed) {
+          process.stdout.write(`${pc2.yellow("Cancelled.")}
+`);
+          return 0;
+        }
+      }
+      await runSupabaseOrThrow(
+        ["db", "reset", "--linked", ...getDbPasswordArgs()],
+        projectRoot,
+        "Remote reset failed."
+      );
+      process.stdout.write(`${pc2.green("Remote reset completed")}
+`);
+      return 0;
+  }
+}
+async function runConfigure(context) {
+  const projectRoot = context.projectRoot;
+  const config2 = await collectSupabaseConfig(projectRoot);
+  if (projectRoot) {
+    writeUruEnv(projectRoot, config2);
+    process.stdout.write(`${pc2.green("Updated .env.local")}
+`);
+  }
+  const payloadPath = writeBootstrapPayload(config2);
+  process.stdout.write(`${pc2.green("Updated runtime bootstrap payload")}
+`);
+  process.stdout.write(`${pc2.dim(`Payload path: ${payloadPath}`)}
+`);
+  return 0;
+}
+async function downloadFile(url, destinationPath) {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Unable to download artifact: ${response.status} ${response.statusText}`);
+  }
+  const arrayBuffer = await response.arrayBuffer();
+  const buffer = Buffer.from(arrayBuffer);
+  writeFileSync(destinationPath, buffer);
+  return buffer.byteLength;
+}
+async function extractArchive(archivePath, outputDir) {
+  if (archivePath.endsWith(".zip")) {
+    await runOrThrow(
+      "ditto",
+      ["-xk", archivePath, outputDir],
+      process.cwd(),
+      "Archive extraction failed."
+    );
+    return;
+  }
+  if (archivePath.endsWith(".tar.gz") || archivePath.endsWith(".tgz")) {
+    await runOrThrow(
+      "tar",
+      ["-xzf", archivePath, "-C", outputDir],
+      process.cwd(),
+      "Archive extraction failed."
+    );
+    return;
+  }
+  throw new Error("Unsupported artifact format. Use a .zip or .tar.gz macOS artifact.");
+}
+async function findFirstAppBundle(dir) {
+  const entries = await readdir(dir);
+  for (const entry of entries) {
+    const fullPath = join4(dir, entry);
+    const entryStat = await stat(fullPath);
+    if (entryStat.isDirectory() && entry.endsWith(".app")) {
+      return fullPath;
+    }
+    if (entryStat.isDirectory()) {
+      const nested = await findFirstAppBundle(fullPath);
+      if (nested) {
+        return nested;
+      }
+    }
+  }
+  return void 0;
+}
+async function installMacosApp(context) {
+  const artifact = await resolveUruMacosArtifact(context.options);
+  const tempRoot = await mkdtemp(join4(tmpdir(), "polterbase-uru-"));
+  const archivePath = join4(tempRoot, artifact.fileName);
+  const extractDir = join4(tempRoot, "extract");
+  mkdirSync(extractDir, { recursive: true });
+  if (artifact.source === "github-release") {
+    const releaseLabel = artifact.tagName ?? "latest";
+    process.stdout.write(
+      `${pc2.dim(`Resolved ${artifact.fileName} from ${artifact.repo} (${releaseLabel})`)}
+`
+    );
+  } else {
+    process.stdout.write(`${pc2.dim(`Using explicit artifact URL: ${artifact.url}`)}
+`);
+  }
+  process.stdout.write(`${pc2.dim("Downloading Uru macOS artifact...")}
+`);
+  const downloadedSize = await downloadFile(artifact.url, archivePath);
+  if (artifact.size && downloadedSize !== artifact.size) {
+    throw new Error(
+      `Downloaded file size mismatch for ${artifact.fileName}. Expected ${artifact.size} bytes but received ${downloadedSize}.`
+    );
+  }
+  process.stdout.write(`${pc2.dim("Extracting artifact...")}
+`);
+  await extractArchive(archivePath, extractDir);
+  const appBundle = await findFirstAppBundle(extractDir);
+  if (!appBundle) {
+    throw new Error("No .app bundle was found inside the downloaded artifact.");
+  }
+  const installDir = context.options.installDir ?? "/Applications";
+  mkdirSync(installDir, { recursive: true });
+  const destination = join4(installDir, "uru.app");
+  if (existsSync3(destination)) {
+    const confirmed = context.options.yes || await promptConfirm(`Replace existing installation at ${destination}?`, false);
+    if (!confirmed) {
+      process.stdout.write(`${pc2.yellow("Cancelled.")}
+`);
+      return 0;
+    }
+    rmSync(destination, { recursive: true, force: true });
+  }
+  await runOrThrow(
+    "cp",
+    ["-R", appBundle, destination],
+    process.cwd(),
+    "App copy failed."
+  );
+  process.stdout.write(`${pc2.green(`Installed Uru to ${destination}`)}
+`);
+  await runConfigure(context);
+  const shouldOpen = context.options.yes || await promptConfirm("Open Uru now?", true);
+  if (shouldOpen) {
+    await runOrThrow("open", ["-a", destination], process.cwd(), "Unable to open Uru.");
+  }
+  return 0;
+}
+var uruProfile = {
+  id: "uru",
+  displayName: "Uru",
+  detect(startDir = process.cwd()) {
+    return findNearestUruRoot(startDir);
+  },
+  resolveProjectRoot(startDir = process.cwd(), explicitPath) {
+    if (explicitPath) {
+      const resolved = resolve3(explicitPath);
+      if (isUruProjectRoot(resolved)) {
+        return resolved;
+      }
+      return findNearestUruRoot(resolved);
+    }
+    return findNearestUruRoot(startDir);
+  },
+  async run(action, context) {
+    switch (action) {
+      case "setup":
+        return runSetup(context);
+      case "link":
+        return runLink(context);
+      case "configure":
+        return runConfigure(context);
+      case "install":
+        if ((context.options.platform ?? "macos") !== "macos") {
+          throw new Error("Only --platform macos is currently supported for Uru install.");
+        }
+        return installMacosApp(context);
+      case "migrate":
+        return runMigration(
+          context,
+          context.options.migrationAction ?? "push"
+        );
+    }
+  }
+};
+
+// src/apps/registry.ts
+var profiles = [uruProfile];
+function getAppProfile(appId) {
+  return profiles.find((profile) => profile.id === appId);
+}
+
+// src/apps/runAppCli.ts
+function assertAppCommand(options) {
+  if (!options.action || !options.app) {
+    throw new Error("Usage: polterbase app <setup|link|migrate|configure|install> <app>");
+  }
+}
+async function runAppCli(options) {
+  assertAppCommand(options);
+  const profile = getAppProfile(options.app);
+  if (!profile) {
+    throw new Error(`Unknown app profile: ${options.app}`);
+  }
+  const projectRoot = profile.resolveProjectRoot(process.cwd(), options.path);
+  process.stdout.write(
+    `${pc3.bold("Polterbase")} ${pc3.dim("app workflow")} ${pc3.bold(profile.displayName)} ${pc3.dim(`(${options.action})`)}
+
+`
+  );
+  return profile.run(options.action, {
+    cwd: process.cwd(),
+    projectRoot,
+    options
+  });
+}
+
 // src/index.tsx
-render(React7.createElement(App));
+async function main() {
+  const parsed = parseCliArgs(process.argv.slice(2));
+  if (parsed.mode === "help") {
+    printCliHelp();
+    return;
+  }
+  if (parsed.mode === "app") {
+    const exitCode = await runAppCli(parsed.options);
+    process.exit(exitCode);
+  }
+  render(React8.createElement(App));
+}
+main().catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  process.stderr.write(`${message}
+`);
+  process.exit(1);
+});