tether-sync 0.4.0 → 0.6.0

package/bin/{chunk-NMLHD2KU.js → chunk-KG4OTE34.js}

@@ -99,7 +99,7 @@ function call(endpoint, method, params = {}, timeoutMs = 10 * 60 * 1e3) {
 }
 
 // packages/client/src/version.js
-var VERSION = "0.4.0";
+var VERSION = "0.6.0";
 
 // packages/client/src/update.js
 import fs2 from "node:fs";

package/bin/{daemon-5IFWP5O3.js → daemon-Z2NE3MNG.js}

@@ -23,7 +23,7 @@ import {
   restage,
   setKeep,
   tetherHome
-} from "./chunk-NMLHD2KU.js";
+} from "./chunk-KG4OTE34.js";
 
 // packages/client/src/daemon.js
 import fs8 from "node:fs";
@@ -45,6 +45,7 @@ var DEFAULTS = {
   // all | errors | off
 };
 var NUMERIC = /* @__PURE__ */ new Set(["tickSeconds", "graceMs"]);
+var MIN_TICK_SECONDS = Number(process.env.TETHER_MIN_TICK_SECONDS) || 10;
 var Config = class {
   constructor(file) {
     this.file = file;
@@ -63,6 +64,7 @@ var Config = class {
     if (NUMERIC.has(key)) {
       value = Number(value);
       if (!Number.isFinite(value) || value <= 0) throw new Error(`${key} must be a positive number`);
+      if (key === "tickSeconds" && value < MIN_TICK_SECONDS) throw new Error(`tickSeconds must be at least ${MIN_TICK_SECONDS}`);
     }
     if (key === "notifications" && !["all", "errors", "off"].includes(value)) throw new Error("notifications must be all, errors or off");
     if (key === "scanRoots" && typeof value === "string") value = value.split(/[;,]/).map((s) => s.trim()).filter(Boolean);
@@ -987,6 +989,7 @@ function walkFiles(root) {
 var UserError = class extends Error {
 };
 var ACTIVE = (i) => i.mode !== "orphaned";
+var FULL_CHECK_MS = 60 * 60 * 1e3;
 var Engine = class {
   constructor({ db, api, cache, tracker, config, log = () => {
   }, notify = () => {
@@ -1445,6 +1448,28 @@ var Engine = class {
     this.log(`${inst.path}: ${what}; file kept, no longer tracked`);
     this.notify({ kind: "orphaned", level: "warn", title: "No longer synced", body: `${path4.basename(inst.path)}: ${what}. Your copy stays on disk but Tether no longer keeps it up to date.`, short: path4.basename(inst.path) });
   }
+  /** What a check asks about; a change cursor is only valid for the same question. */
+  checkKey(insts) {
+    return insts.map((i) => `${i.artifactId}@${i.baseVersion}:${i.mode}`).join(",");
+  }
+  /**
+   * The change cursor from the last full check, if it can be reused: same instances, nothing
+   * pending, no live sessions, and a full check at least every FULL_CHECK_MS as a safety net.
+   */
+  reusableCursor(insts) {
+    const f = this.feed;
+    if (!f || this.realtimeActive || Date.now() - f.at > FULL_CHECK_MS) return void 0;
+    return f.key === this.checkKey(insts) ? f.cursor : void 0;
+  }
+  /**
+   * Keeps the server's cursor only when nothing is pending here: an incoming version held back
+   * (editing, unmanaged, waiting for git) must be offered again by a full check once it can apply.
+   */
+  rememberCursor(cursor) {
+    const insts = this.db.all().filter(ACTIVE);
+    const settled = insts.every((i) => i.remoteVersion == null || i.remoteVersion === i.baseVersion);
+    this.feed = cursor !== void 0 && settled ? { cursor, key: this.checkKey(insts), at: Date.now() } : null;
+  }
   /** One batched call for all instances (DESIGN §6.1 step 2). */
   async checkRemote() {
     const insts = this.db.all().filter(ACTIVE);
@@ -1452,10 +1477,15 @@ var Engine = class {
       this.offline = null;
       return;
     }
-    let results;
+    let results, cursor;
     try {
-      ({ results } = await this.api.call("POST", "/sync/check", { items: insts.map((i) => ({ artifactId: i.artifactId, version: i.baseVersion })) }));
+      const rootOf = (i) => i.folderInstanceId ? this.db.get(i.folderInstanceId)?.artifactId : void 0;
+      const items = insts.map((i) => ({ artifactId: i.artifactId, version: i.baseVersion, root: rootOf(i) }));
+      const body = { items, cursor: this.reusableCursor(insts) };
+      const res = await this.api.call("POST", "/sync/check", body);
       this.offline = null;
+      if (res.unchanged) return;
+      ({ results, cursor } = res);
     } catch (e) {
       if (e instanceof OfflineError || e instanceof ApiError && e.status === 401) {
         this.offline = e.message;
@@ -1468,6 +1498,7 @@ var Engine = class {
     const folders = [];
     insts.forEach((inst, idx) => {
       const r = results[idx];
+      if (!r) return;
       const cur = this.db.get(inst.instanceId);
       if (!cur || cur.mode === "orphaned") return;
       if (r.status === "gone") return this.orphan(cur, r.reason);
@@ -1547,6 +1578,8 @@ var Engine = class {
       this.log(`${folder.path}: new file ${child.relPath}`);
     }
     for (const f of folders) if (!waiting.has(f.inst.instanceId)) this.db.update(f.inst.instanceId, { baseVersion: f.state.version });
+    if (results.some((r) => r && r.status !== "ok")) this.activityAt = Date.now();
+    this.rememberCursor(cursor);
   }
   /** Normal mode: write an incoming version (content and/or layout). */
   applyIncoming(inst, state) {
@@ -1613,6 +1646,22 @@ var Engine = class {
     const local = readLocal(p, inst.eolMode);
     return local?.hash === inst.baseHash;
   }
+  /**
+   * Follow mode, just before a revert: is this content git's own (a git operation that started
+   * after this pass checked, e.g. a cherry-pick between writing the file and moving HEAD)? Asks git
+   * afresh, since the pass's busy check may be stale by now.
+   */
+  gitWroteIt(inst) {
+    if (inst.gitMode !== "follow" || !inst.gitRoot) return false;
+    if (gitBusy(inst.gitDir)) return true;
+    const blob = fileBlob(inst.gitRoot, inst.path);
+    if (!blob) return false;
+    if (blob === indexBlob(inst.gitRoot, inst.path) || blob === blobAt(inst.gitRoot, "HEAD", inst.path)) {
+      this.gitPassDue = true;
+      return true;
+    }
+    return false;
+  }
   /** Normal mode: restore missing files, put moved files back, revert local edits. */
   async enforceLocal() {
     const restores = this.db.all().filter((i) => ACTIVE(i) && i.needsRestore && i.mode === "normal");
@@ -1643,6 +1692,7 @@ var Engine = class {
           continue;
         }
         if (!this.cache.has(cur.baseHash)) continue;
+        if (this.gitWroteIt(cur)) continue;
         this.db.update(cur.instanceId, { ...this.writeInstance(cur, cur.path, cur.baseHash), lastError: null });
         this.log(`${cur.path}: local change reverted (use \`tether edit\` to change it)`);
         const byGit = cur.gitMode === "keep";
@@ -2454,9 +2504,90 @@ $x = New-Object Windows.Data.Xml.Dom.XmlDocument; $x.LoadXml('${xml.replace(/'/g
   }
 };
 
+// packages/client/src/feed.js
+var RETRY_MS = 5 * 60 * 1e3;
+var FeedListener = class {
+  /** onChange(seq) is called with the feed counter on every snapshot from the server. */
+  constructor({ api, log, onChange }) {
+    this.api = api;
+    this.log = log;
+    this.onChange = onChange;
+    this.live = false;
+    this.unsupported = false;
+    this.session = 0;
+  }
+  async start() {
+    if (this.unsupported || this.unsub || this.starting) return;
+    this.starting = true;
+    const session = ++this.session;
+    try {
+      const t = await this.api.call("POST", "/feed/token");
+      const [{ initializeApp }, A, F] = await Promise.all([import("firebase/app"), import("firebase/auth"), import("firebase/firestore")]);
+      if (session !== this.session) return;
+      this.app = initializeApp(t.firebase, `tether-feed-${session}-${Date.now()}`);
+      const auth = A.getAuth(this.app);
+      const db = F.getFirestore(this.app);
+      if (t.emulators?.auth) A.connectAuthEmulator(auth, `http://${t.emulators.auth}`, { disableWarnings: true });
+      if (t.emulators?.firestore) {
+        const [host, port] = t.emulators.firestore.split(":");
+        F.connectFirestoreEmulator(db, host, Number(port));
+      }
+      await A.signInWithCustomToken(auth, t.customToken);
+      if (session !== this.session) return this.dispose();
+      this.unsub = F.onSnapshot(F.doc(db, "feeds", t.uid), { includeMetadataChanges: true }, (snap) => {
+        const wasLive = this.live;
+        this.live = !snap.metadata.fromCache;
+        if (this.live && !wasLive) this.log("push channel connected");
+        if (this.live) this.onChange(snap.get("seq") ?? 0);
+      }, (e) => this.fail(e, session));
+    } catch (e) {
+      this.fail(e, session);
+    } finally {
+      this.starting = false;
+    }
+  }
+  fail(e, session) {
+    if (session !== this.session) return;
+    if (e instanceof ApiError && e.status === 404) {
+      this.unsupported = true;
+      this.stop();
+      return;
+    }
+    this.log(`push channel unavailable (${e.message}); polling until it reconnects`);
+    this.stop();
+    clearTimeout(this.retry);
+    this.retry = setTimeout(() => this.start(), RETRY_MS);
+    this.retry.unref?.();
+  }
+  stop() {
+    this.session++;
+    clearTimeout(this.retry);
+    this.unsub?.();
+    this.unsub = null;
+    if (this.live) this.log("push channel closed");
+    this.live = false;
+    this.dispose();
+  }
+  dispose() {
+    const app = this.app;
+    this.app = null;
+    if (app) import("firebase/app").then(({ deleteApp }) => deleteApp(app)).catch(() => {
+    });
+  }
+  /** After a login, logout or server change: start over (or stay off when signed out). */
+  restart() {
+    this.unsupported = false;
+    this.stop();
+    this.start();
+  }
+};
+
 // packages/client/src/daemon.js
 import { fileURLToPath } from "node:url";
 var REALTIME_TICK_SECONDS = 3;
+var IDLE_AFTER_MS = 10 * 60 * 1e3;
+var IDLE_MAX_SECONDS = 180;
+var PUSH_TICK_SECONDS = 15 * 60;
 var UPDATE_CHECK_MS = 24 * 60 * 60 * 1e3;
 async function runDaemon() {
   const home = tetherHome();
@@ -2494,23 +2625,54 @@ async function runDaemon() {
   let realtimeTimer = null;
   let stopping = false;
   let latest = null;
-  async function runTick(opts) {
+  let remoteAt = 0;
+  async function runTick({ remote } = {}) {
+    remote ??= !feed.live || engine.realtimeActive || Date.now() - remoteAt >= PUSH_TICK_SECONDS * 1e3;
+    if (remote) remoteAt = Date.now();
     try {
-      await engine.locked(() => engine.tick(opts));
+      await engine.locked(() => engine.tick({ remote }));
     } catch (e) {
       log(`tick failed: ${e.stack || e.message}`);
       notifier.notify({ kind: "error", level: "error", key: "tick-failed", cooldownMs: 3600 * 1e3, title: "Tether hit an error", body: `${e.message}. Run "tether log" for details.` });
     }
+    if (engine.gitPassDue) {
+      engine.gitPassDue = false;
+      gitPassSoon();
+    }
     refreshWatchers();
     scheduleGrace();
     schedule();
   }
+  let activeAt = Date.now();
+  let timerDue = 0;
+  function interval() {
+    const base = Math.max(MIN_TICK_SECONDS, config.get("tickSeconds"));
+    if (engine.realtimeActive) return Math.min(base, REALTIME_TICK_SECONDS);
+    const idle = Date.now() - Math.max(activeAt, engine.activityAt ?? 0);
+    if (idle < IDLE_AFTER_MS) return base;
+    return Math.max(base, Math.min(IDLE_MAX_SECONDS, base * 2 ** Math.floor(idle / IDLE_AFTER_MS)));
+  }
   function schedule() {
     clearTimeout(timer);
     if (stopping) return;
-    const seconds = engine.realtimeActive ? Math.min(config.get("tickSeconds"), REALTIME_TICK_SECONDS) : config.get("tickSeconds");
+    const seconds = interval();
+    timerDue = Date.now() + seconds * 1e3;
     timer = setTimeout(() => runTick(), seconds * 1e3);
   }
+  const feed = new FeedListener({
+    api,
+    log,
+    onChange: (seq) => {
+      if (stopping || engine.feed?.cursor === seq) return;
+      clearTimeout(timer);
+      timerDue = Date.now() + 300;
+      timer = setTimeout(() => runTick({ remote: true }), 300);
+    }
+  });
+  function markActive() {
+    activeAt = Date.now();
+    if (timer && timerDue - activeAt > interval() * 1e3) schedule();
+  }
   function realtimePass(delay = 1e3) {
     if (stopping || !engine.realtimeInstances().length) return;
     clearTimeout(realtimeTimer);
@@ -2587,6 +2749,7 @@ async function runDaemon() {
       if (watchers.has(dir)) continue;
       try {
         const w = kind === "git" ? fs8.watch(dir, { persistent: false }, () => gitPassSoon()) : fs8.watch(dir, { recursive: kind, persistent: false }, () => {
+          markActive();
           quickPass(250);
           realtimePass();
         });
@@ -2631,7 +2794,7 @@ async function runDaemon() {
     return { state, url: `${config.consoleUrl.replace(/\/$/, "")}/cli-login?port=${port}&state=${state}` };
   }
   const L = (fn) => (params) => engine.locked(() => fn(params));
-  const soon = () => setTimeout(() => runTick(), 10);
+  const soon = () => setTimeout(() => runTick({ remote: true }), 10);
   const handlers = {
     ping: () => ({ pid: process.pid, version: VERSION, home, tracker: tracker.name, server: config.get("server") }),
     async status(p) {
@@ -2647,11 +2810,13 @@ async function runDaemon() {
       };
     },
     sync: async () => {
-      await runTick();
+      await runTick({ remote: true });
       return { offline: engine.offline };
     },
     async "login.password"({ email, password, signup }) {
       const user = await api.passwordLogin({ email, password, signup });
+      engine.feed = null;
+      feed.restart();
       soon();
       return user;
     },
@@ -2661,13 +2826,19 @@ async function runDaemon() {
       if (!p) throw new UserError("no login in progress");
       try {
         const user = await p;
+        engine.feed = null;
+        feed.restart();
         soon();
         return user;
       } finally {
         logins.delete(state);
       }
     },
-    logout: async () => api.logout(),
+    logout: async () => {
+      engine.feed = null;
+      feed.stop();
+      return api.logout();
+    },
     whoami: () => api.call("GET", "/me"),
     manage: L((p) => engine.manage(p)),
     add: L((p) => engine.add(p)),
@@ -2727,6 +2898,10 @@ async function runDaemon() {
     "config.get": ({ key }) => key ? { [key]: config.get(key) } : config.values,
     "config.set": ({ key, value }) => {
       config.set(key, value);
+      if (key === "server") {
+        engine.feed = null;
+        feed.restart();
+      }
       if (key === "tickSeconds") schedule();
       return { [key]: config.get(key) };
     },
@@ -2740,6 +2915,7 @@ async function runDaemon() {
   async function handle(method, params) {
     const h = handlers[method];
     if (!h) throw new UserError(`unknown command ${method}`);
+    if (method !== "ping") markActive();
     try {
       const result = await h(params);
       if (CHANGES_WATCHED.has(method)) refreshWatchers();
@@ -2763,6 +2939,7 @@ async function runDaemon() {
     clearInterval(updateTimer);
     clearInterval(repoTimer);
     clearTimeout(gitTimer);
+    feed.stop();
     for (const w of watchers.values()) w.close();
     server.close();
     engine.locked(() => db.close()).finally(() => {
@@ -2782,6 +2959,7 @@ async function runDaemon() {
   const updateTimer = setInterval(checkForUpdate, UPDATE_CHECK_MS);
   setTimeout(checkForUpdate, 5e3);
   await runTick();
+  feed.start();
 }
 export {
   VERSION,

package/bin/tether.js

@@ -13,7 +13,7 @@ import {
   npmInstall,
   prefixOf,
   tetherHome
-} from "./chunk-NMLHD2KU.js";
+} from "./chunk-KG4OTE34.js";
 
 // packages/client/src/cli.js
 import path2 from "node:path";

package/bin/tetherd.js

@@ -4,7 +4,7 @@
 process.removeAllListeners("warning");
 var i = process.argv.indexOf("--home");
 if (i > 0 && process.argv[i + 1]) process.env.TETHER_HOME = process.argv[i + 1];
-var { runDaemon } = await import("./daemon-5IFWP5O3.js");
+var { runDaemon } = await import("./daemon-Z2NE3MNG.js");
 runDaemon().catch((e) => {
   if (e.code === "EADDRINUSE") {
     console.error("tetherd is already running");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tether-sync",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "Keep files identical to a central source of truth, wherever they live on your machine.",
   "type": "module",
   "bin": {
@@ -21,7 +21,8 @@
   "dependencies": {
     "koffi": "^3.3.3",
     "commander": "^14.0.1",
-    "diff": "^8.0.2"
+    "diff": "^8.0.2",
+    "firebase": "^12.19.0"
   },
   "keywords": [
     "sync",