supbuddy 3.2.5 → 3.2.7

package/dist/bin.js

@@ -19807,7 +19807,7 @@ function cliBuildKind(env3 = process.env) {
   return raw === "host" || raw === "npm" ? raw : "dev";
 }
 function cliVersion(env3 = process.env) {
-  return "3.2.5".trim() || "0.0.0-dev";
+  return "3.2.7".trim() || "0.0.0-dev";
 }
 function isDevBuild(env3) {
   return cliBuildKind(env3) === "dev";

package/dist/daemon/worker.cjs

@@ -44969,6 +44969,18 @@ async function daemonSyncStart(projectId, authority) {
   const m = await __vitePreload(() => Promise.resolve().then(() => projectSync), false ? __VITE_PRELOAD__ : void 0);
   return m.syncStart(syncDeps(), { projectId, authority });
 }
+async function daemonSyncReattach() {
+  const m = await __vitePreload(() => Promise.resolve().then(() => daemonSync), false ? __VITE_PRELOAD__ : void 0);
+  const known = useStore.getState().projects.filter((p) => p.cloud?.stackId && p.path).map((p) => ({
+    projectId: p.id,
+    stackId: p.cloud.stackId,
+    localPath: p.path,
+    // Unknowable after a restart and inert for an adopted session — see reattachSessions.
+    authority: "cloud"
+  }));
+  if (known.length === 0) return [];
+  return m.reattachSessions(syncDeps(), known);
+}
 async function daemonSyncStatus(projectId) {
   const m = await __vitePreload(() => Promise.resolve().then(() => projectSync), false ? __VITE_PRELOAD__ : void 0);
   let stackStopped = false;
@@ -52012,6 +52024,9 @@ async function handleStartProxy() {
     reconcileAllProjectServices().catch((err) => {
       console.warn("[Worker] boot rescan failed:", err.message);
     });
+    daemonSyncReattach().then((ids) => {
+      if (ids.length) console.log(`[Worker] re-attached ${ids.length} sync session(s)`);
+    }).catch((err) => console.warn("[Worker] sync re-attach failed:", err.message));
     if (store2.settings.lanSharing) {
       startMdnsResponder();
     }
@@ -57186,6 +57201,43 @@ exec /usr/bin/${name2} ${opts} "$@"
   });
   return { ok: true, session };
 }
+async function inspectLocalWork(git, localPath) {
+  const out = { uncommitted: 0, unpushed: 0, noUpstream: false, notAGitRepo: false };
+  const inside = await git(["rev-parse", "--is-inside-work-tree"], localPath).catch(() => ({ exitCode: 1, stdout: "" }));
+  if (inside.exitCode !== 0 || inside.stdout.trim() !== "true") {
+    out.notAGitRepo = true;
+    return out;
+  }
+  const status = await git(["status", "--porcelain"], localPath).catch(() => ({ exitCode: 1, stdout: "" }));
+  if (status.exitCode === 0) {
+    out.uncommitted = status.stdout.split("\n").filter((l) => l.trim()).length;
+  }
+  const counts = await git(["rev-list", "--count", "@{upstream}..HEAD"], localPath).catch(() => ({ exitCode: 1, stdout: "" }));
+  if (counts.exitCode === 0) {
+    out.unpushed = Number.parseInt(counts.stdout.trim(), 10) || 0;
+  } else {
+    out.noUpstream = true;
+  }
+  return out;
+}
+function hasWorkAtRisk(risk) {
+  return risk.notAGitRepo || risk.noUpstream || risk.uncommitted > 0 || risk.unpushed > 0;
+}
+function describeWorkAtRisk(risk, localPath) {
+  if (risk.notAGitRepo) {
+    return `${localPath} is not a git repository, so a one-way sync from the cloud would delete anything here that the box does not have, with no way to recover it. Choose "this machine's copy" as the authority, or start sync on a directory under version control.`;
+  }
+  const parts = [];
+  if (risk.uncommitted > 0) {
+    parts.push(`${risk.uncommitted} uncommitted change${risk.uncommitted === 1 ? "" : "s"} (commit or stash them)`);
+  }
+  if (risk.noUpstream) {
+    parts.push("a branch that has never been pushed, so none of its commits are on the box (push it first)");
+  } else if (risk.unpushed > 0) {
+    parts.push(`${risk.unpushed} unpushed commit${risk.unpushed === 1 ? "" : "s"} (push them first)`);
+  }
+  return `Refusing to overwrite this machine: ${localPath} has ${parts.join(", and ")}. The box clones the repository from its REMOTE, so it has never seen that work, and a first sync with the cloud as authority would delete it. Choose "this machine's copy" instead, or resolve the above and try again.`;
+}
 const execFileAsync$1 = require$$0$3.promisify(node_child_process.execFile);
 const sessions = /* @__PURE__ */ new Map();
 const shimDirFor = (dataDir) => path$1.join(tailnetPaths(dataDir).dir, "shim");
@@ -57237,14 +57289,30 @@ function runtimeDeps(deps) {
     })
   };
 }
+const defaultGit = async (gitArgs, cwd) => {
+  try {
+    const { stdout } = await execFileAsync$1("git", gitArgs, { cwd, timeout: 15e3 });
+    return { exitCode: 0, stdout };
+  } catch (e) {
+    const err = e;
+    return { exitCode: typeof err.code === "number" ? err.code : 1, stdout: String(err.stdout ?? "") };
+  }
+};
 async function startProjectSync(deps, args) {
   const existing = sessions.get(args.projectId);
   if (existing) return { ok: true, session: existing };
+  if (args.authority === "cloud" && !args.force) {
+    const risk = await inspectLocalWork(deps.git ?? defaultGit, args.localPath);
+    if (hasWorkAtRisk(risk)) {
+      return { ok: false, unavailable: describeWorkAtRisk(risk, args.localPath) };
+    }
+  }
   const res = await startSync(runtimeDeps(deps), args);
   if (!res.ok) return res;
   sessions.set(args.projectId, res.session);
   return res;
 }
+const PAUSED_WHEN_STOPPED = /* @__PURE__ */ new Set(["connecting", "idle", "unknown"]);
 async function projectSyncStatus(deps, projectId, opts = {}) {
   const state = sessions.get(projectId);
   if (!state) return null;
@@ -57258,7 +57326,7 @@ async function projectSyncStatus(deps, projectId, opts = {}) {
       next = { ...next, promoteError: e instanceof Error ? e.message : String(e) };
     }
   }
-  if (opts.stackStopped && (next.phase === "connecting" || next.phase === "idle")) {
+  if (opts.stackStopped && PAUSED_WHEN_STOPPED.has(next.phase)) {
     next = { ...next, phase: "paused" };
   }
   sessions.set(projectId, next);
@@ -57273,6 +57341,46 @@ async function stopProjectSync(deps, projectId) {
   sessions.delete(projectId);
   return { stopped: true };
 }
+async function reattachSessions(deps, known) {
+  const rt = runtimeDeps(deps);
+  const reattached = [];
+  for (const k of known) {
+    if (sessions.has(k.projectId)) continue;
+    const probe2 = await rt.runMutagen(["sync", "list", sessionName(k.stackId)]);
+    if (probe2.exitCode !== 0) continue;
+    sessions.set(k.projectId, {
+      sessionId: sessionName(k.stackId),
+      stackId: k.stackId,
+      localPath: k.localPath,
+      remoteEndpoint: "",
+      // filled by the next observe; not needed to adopt or to stop
+      authority: k.authority,
+      phase: "connecting",
+      conflictCount: 0,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      // Adopted sessions are already past their first pass — Mutagen would not be running them
+      // otherwise — so treating one as unseeded could re-trigger a one-way replica over live work.
+      seeded: true,
+      // And already PROMOTED, for the same reason. Without this the next status poll would "promote"
+      // a session that is already two-way, by TERMINATING and recreating it — and recreate orders
+      // alpha/beta from `authority`, which a restarted daemon cannot know because nothing persists it.
+      promoted: true
+    });
+    reattached.push(k.projectId);
+  }
+  return reattached;
+}
+function __resetSessionsForTest() {
+  sessions.clear();
+}
+const daemonSync = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  __resetSessionsForTest,
+  projectSyncStatus,
+  reattachSessions,
+  startProjectSync,
+  stopProjectSync
+}, Symbol.toStringTag, { value: "Module" }));
 function syncDataDir() {
   const override = nodeProcess.env.SUPBUDDY_STATE_DIR;
   if (override) return override;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "supbuddy",
-  "version": "3.2.5",
+  "version": "3.2.7",
   "description": "Run multiple Supabase projects at once on custom local domains with HTTPS. A headless CLI and daemon (proxy, DNS, Supabase/Compose lifecycle, MCP) for macOS and Linux.",
   "keywords": [
     "supabase",