tether-sync 0.1.0 → 0.4.0

package/README.md

@@ -1,21 +1,27 @@
-# tether-sync
-
-Keep files and folders identical to a central source of truth, wherever they live on your machine.
-
-```sh
-npm install -g tether-sync
-tether login                              # opens the browser to sign in
-tether pull <share-id>                    # get a managed copy of a file or folder
-tether status
-```
-
-Owners publish files with `tether manage <path> --repo <repo>` and share the printed share ID. A managed copy:
-- follows the file when you move or rename it
-- reverts local edits until you run `tether edit <path>`
-- pushes your changes with `tether done <path>` (if you are an editor)
-
-Run `tether --help` for every command. The web console is at https://tether-b10cf.web.app.
-
-Requires Node.js 22.13 or newer. Windows (NTFS/ReFS) is fully supported; Linux support is experimental.
-
-Source: https://github.com/SaiEthihasChanda/Tether
+# tether-sync
+
+Keep files and folders identical to a central source of truth, wherever they live on your machine.
+
+```sh
+npm install -g tether-sync
+tether login                              # opens the browser to sign in
+tether pull <share-id>                    # get a managed copy of a file or folder
+tether status
+```
+
+Owners publish files with `tether manage <path> --repo <repo>` and share the printed share ID. A managed copy:
+- follows the file when you move or rename it
+- reverts local edits until you run `tether edit <path>`
+- pushes your changes with `tether done <path>` (if you are an editor)
+
+Editors can also run `tether edit <path> --realtime` to push every save live, one live editor per file. `tether update` installs the latest version.
+
+Inside a git repository, Tether asks whether git's changes should be reverted (keep), or accepted and published after pull, checkout and merge (follow, for editors). Change it with `tether git <path> --mode`.
+
+Desktop notifications cover reverted changes, conflicts, lost live sessions and revoked access. Set them with `tether config set notifications all|errors|off`.
+
+Run `tether --help` for every command. The web console is at https://tether-b10cf.web.app.
+
+Requires Node.js 22.13 or newer. Windows (NTFS/ReFS) is fully supported; Linux support is experimental.
+
+Source: https://github.com/SaiEthihasChanda/Tether

package/bin/chunk-NMLHD2KU.js

@@ -0,0 +1,382 @@
+// packages/client/src/paths.js
+import os from "node:os";
+import path from "node:path";
+import crypto from "node:crypto";
+var isWindows = process.platform === "win32";
+function tetherHome() {
+  if (process.env.TETHER_HOME) return path.resolve(process.env.TETHER_HOME);
+  if (isWindows) return path.join(process.env.LOCALAPPDATA || path.join(os.homedir(), "AppData", "Local"), "Tether");
+  return path.join(process.env.XDG_STATE_HOME || path.join(os.homedir(), ".local", "state"), "tether");
+}
+function ipcEndpoint(home = tetherHome()) {
+  const tag = crypto.createHash("sha1").update(home.toLowerCase()).digest("hex").slice(0, 12);
+  if (isWindows) return `\\\\.\\pipe\\tether-${os.userInfo().username}-${tag}`;
+  return path.join(home, "tetherd.sock");
+}
+var files = (home = tetherHome()) => ({
+  db: path.join(home, "tether.db"),
+  blobs: path.join(home, "blobs"),
+  config: path.join(home, "config.json"),
+  credentials: path.join(home, isWindows ? "credentials.bin" : "credentials.json"),
+  log: path.join(home, "tetherd.log"),
+  pid: path.join(home, "tetherd.pid")
+});
+
+// packages/client/src/ipc.js
+import net from "node:net";
+import fs from "node:fs";
+var IpcError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+  }
+};
+async function listen(endpoint, handler) {
+  if (!isWindows && fs.existsSync(endpoint)) {
+    const alive = await call(endpoint, "ping", {}, 1e3).then(() => true, () => false);
+    if (alive) throw new IpcError("another tetherd is already running", "EADDRINUSE");
+    fs.rmSync(endpoint, { force: true });
+  }
+  const server = net.createServer((socket) => {
+    let buf = "";
+    socket.setEncoding("utf8");
+    socket.on("data", async (chunk) => {
+      buf += chunk;
+      const nl = buf.indexOf("\n");
+      if (nl < 0) return;
+      let req;
+      try {
+        req = JSON.parse(buf.slice(0, nl));
+      } catch {
+        socket.end(JSON.stringify({ error: { message: "bad request" } }) + "\n");
+        return;
+      }
+      buf = "";
+      let res;
+      try {
+        res = { result: await handler(req.method, req.params ?? {}) ?? null };
+      } catch (e) {
+        res = { error: { message: e.message, code: e.code ?? e.name, status: e.status } };
+      }
+      socket.end(JSON.stringify(res) + "\n");
+    });
+    socket.on("error", () => {
+    });
+  });
+  await new Promise((resolve, reject) => {
+    server.once("error", (e) => reject(e.code === "EADDRINUSE" ? new IpcError("another tetherd is already running", "EADDRINUSE") : e));
+    server.listen(endpoint, resolve);
+  });
+  if (!isWindows) fs.chmodSync(endpoint, 384);
+  return server;
+}
+function call(endpoint, method, params = {}, timeoutMs = 10 * 60 * 1e3) {
+  return new Promise((resolve, reject) => {
+    const socket = net.connect(endpoint);
+    let buf = "";
+    const timer = setTimeout(() => {
+      socket.destroy();
+      reject(new IpcError("the daemon did not answer in time", "ETIMEDOUT"));
+    }, timeoutMs);
+    socket.setEncoding("utf8");
+    socket.on("connect", () => socket.write(JSON.stringify({ method, params }) + "\n"));
+    socket.on("data", (c) => buf += c);
+    socket.on("error", (e) => {
+      clearTimeout(timer);
+      reject(new IpcError("the Tether daemon is not running", e.code === "ENOENT" || e.code === "ECONNREFUSED" ? "ENODAEMON" : e.code));
+    });
+    socket.on("end", () => {
+      clearTimeout(timer);
+      try {
+        const res = JSON.parse(buf);
+        if (res.error) reject(new IpcError(res.error.message, res.error.code));
+        else resolve(res.result);
+      } catch {
+        reject(new IpcError("invalid response from the daemon"));
+      }
+    });
+  });
+}
+
+// packages/client/src/version.js
+var VERSION = "0.4.0";
+
+// packages/client/src/update.js
+import fs2 from "node:fs";
+import path2 from "node:path";
+import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+var PACKAGE = "tether-sync";
+var registry = () => (process.env.TETHER_UPDATE_REGISTRY || "https://registry.npmjs.org").replace(/\/$/, "");
+async function latestVersion() {
+  try {
+    const res = await fetch(`${registry()}/${PACKAGE}/latest`, { signal: AbortSignal.timeout(1e4) });
+    if (!res.ok) return null;
+    return (await res.json()).version ?? null;
+  } catch {
+    return null;
+  }
+}
+function isNewer(a, b) {
+  if (!a || !b) return false;
+  const parse = (v) => {
+    const [core, pre] = v.split("-");
+    return { nums: core.split(".").map((n) => Number(n) || 0), pre: pre ?? null };
+  };
+  const x = parse(a);
+  const y = parse(b);
+  for (let i = 0; i < 3; i++) if ((x.nums[i] ?? 0) !== (y.nums[i] ?? 0)) return (x.nums[i] ?? 0) > (y.nums[i] ?? 0);
+  if (x.pre === y.pre) return false;
+  if (x.pre === null) return true;
+  if (y.pre === null) return false;
+  return x.pre > y.pre;
+}
+function installDir(from = fileURLToPath(import.meta.url)) {
+  const dir = path2.resolve(path2.dirname(from), "..");
+  try {
+    return JSON.parse(fs2.readFileSync(path2.join(dir, "package.json"), "utf8")).name === PACKAGE ? dir : null;
+  } catch {
+    return null;
+  }
+}
+function prefixOf(pkgDir, windows = isWindows) {
+  const parent = path2.dirname(path2.dirname(pkgDir));
+  return !windows && path2.basename(parent) === "lib" ? path2.dirname(parent) : parent;
+}
+function npmInstall(spec, prefix) {
+  const args = ["install", "-g", "--prefix", prefix, spec];
+  const bin = path2.dirname(process.execPath);
+  const npmCli = [path2.join(bin, "node_modules", "npm", "bin", "npm-cli.js"), path2.join(bin, "..", "lib", "node_modules", "npm", "bin", "npm-cli.js")].find((p) => fs2.existsSync(p));
+  const r = npmCli ? spawnSync(process.execPath, [npmCli, ...args], { stdio: "inherit" }) : spawnSync(isWindows ? "npm.cmd" : "npm", args.map((a) => isWindows ? `"${a}"` : a), { stdio: "inherit", shell: isWindows });
+  return r.status ?? 1;
+}
+
+// packages/client/src/git.js
+import fs3 from "node:fs";
+import path3 from "node:path";
+import { execFileSync, spawnSync as spawnSync2 } from "node:child_process";
+var GIT_MODES = ["keep", "follow"];
+var gitExe;
+function gitBinary() {
+  if (gitExe !== void 0) return gitExe;
+  const candidates = ["git"];
+  if (isWindows) {
+    const pf = [process.env.ProgramFiles, process.env["ProgramFiles(x86)"], process.env.LOCALAPPDATA && path3.join(process.env.LOCALAPPDATA, "Programs")].filter(Boolean);
+    for (const p of pf) candidates.push(path3.join(p, "Git", "cmd", "git.exe"));
+    const desktop = process.env.LOCALAPPDATA && path3.join(process.env.LOCALAPPDATA, "GitHubDesktop");
+    if (desktop && fs3.existsSync(desktop)) {
+      for (const app of fs3.readdirSync(desktop).filter((d) => d.startsWith("app-")).sort().reverse()) {
+        candidates.push(path3.join(desktop, app, "resources", "app", "git", "cmd", "git.exe"));
+      }
+    }
+  } else candidates.push("/usr/bin/git", "/usr/local/bin/git");
+  gitExe = candidates.find((c) => spawnSync2(c, ["--version"], { stdio: "ignore", windowsHide: true }).status === 0) ?? null;
+  return gitExe;
+}
+function git(cwd, args) {
+  const exe = gitBinary();
+  if (!exe) throw new Error("git is not installed");
+  return execFileSync(exe, ["-C", cwd, ...args], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], windowsHide: true, maxBuffer: 16 * 1024 * 1024 }).replace(/\r?\n$/, "");
+}
+function gitOk(cwd, args) {
+  const exe = gitBinary();
+  return !!exe && spawnSync2(exe, ["-C", cwd, ...args], { stdio: "ignore", windowsHide: true }).status === 0;
+}
+function findRepo(p) {
+  let dir = path3.resolve(p);
+  while (!fs3.existsSync(dir) || !fs3.statSync(dir).isDirectory()) {
+    const up = path3.dirname(dir);
+    if (up === dir) return null;
+    dir = up;
+  }
+  if (gitBinary()) {
+    try {
+      const [root, gitDir] = git(dir, ["rev-parse", "--show-toplevel", "--absolute-git-dir"]).split(/\r?\n/);
+      return { root: path3.resolve(root), gitDir: path3.resolve(gitDir) };
+    } catch {
+      return null;
+    }
+  }
+  for (let d = dir; ; d = path3.dirname(d)) {
+    const dot = path3.join(d, ".git");
+    const st = fs3.existsSync(dot) ? fs3.statSync(dot) : null;
+    if (st?.isDirectory()) return { root: d, gitDir: dot };
+    if (st?.isFile()) {
+      const m = fs3.readFileSync(dot, "utf8").match(/^gitdir:\s*(.+)$/m);
+      if (m) return { root: d, gitDir: path3.resolve(d, m[1].trim()) };
+    }
+    if (path3.dirname(d) === d) return null;
+  }
+}
+function gitBusy(gitDir) {
+  if (!gitDir) return null;
+  const has = (f) => fs3.existsSync(path3.join(gitDir, f));
+  if (has("index.lock")) return "git is running";
+  if (has("MERGE_HEAD")) return "merge in progress";
+  if (has("rebase-merge") || has("rebase-apply")) return "rebase in progress";
+  if (has("CHERRY_PICK_HEAD")) return "cherry-pick in progress";
+  if (has("REVERT_HEAD")) return "revert in progress";
+  return null;
+}
+var rel = (root, abs) => path3.relative(root, abs).split(path3.sep).join("/");
+var head = (root) => {
+  try {
+    return git(root, ["rev-parse", "--verify", "-q", "HEAD"]);
+  } catch {
+    return null;
+  }
+};
+function fileBlob(root, abs) {
+  try {
+    return git(root, ["-c", "filter.tether-keep.clean=", "hash-object", `--path=${rel(root, abs)}`, "--", abs]);
+  } catch {
+    return null;
+  }
+}
+function blobAt(root, rev, abs) {
+  try {
+    return git(root, ["rev-parse", "--verify", "-q", `${rev}:${rel(root, abs)}`]);
+  } catch {
+    return null;
+  }
+}
+function indexBlob(root, abs) {
+  try {
+    const line = git(root, ["ls-files", "-s", "--", rel(root, abs)]);
+    return line ? line.split(/\s+/)[1] : null;
+  } catch {
+    return null;
+  }
+}
+function changeFromGit(root, abs) {
+  const blob = fileBlob(root, abs);
+  if (!blob) return { fromGit: false };
+  const h = head(root);
+  if (h && blobAt(root, "HEAD", abs) === blob) return { fromGit: true, commit: h };
+  if (indexBlob(root, abs) === blob) return { fromGit: true, commit: null };
+  return { fromGit: false };
+}
+var isTracked = (root, abs) => gitOk(root, ["ls-files", "--error-unmatch", "--", rel(root, abs)]);
+var FILTER = "tether-keep";
+var CLEAN = `sh -c 'git cat-file blob ":$1" 2>/dev/null || cat' -- %f`;
+function attributesFile(root) {
+  return path3.resolve(root, git(root, ["rev-parse", "--git-path", "info/attributes"]));
+}
+function attrLine(relPath) {
+  const pattern = /[\s"\\]/.test(relPath) ? `"/${relPath.replace(/["\\]/g, "\\$&")}"` : `/${relPath.replace(/[*?[\]!]/g, "\\$&")}`;
+  return `${pattern} filter=${FILTER}`;
+}
+var readLines = (file) => fs3.existsSync(file) ? fs3.readFileSync(file, "utf8").split(/\r?\n/).filter((l) => l !== "") : [];
+function setKeep(root, abs, on) {
+  if (!gitBinary()) return false;
+  try {
+    const file = attributesFile(root);
+    const line = attrLine(rel(root, abs));
+    const lines = readLines(file);
+    const has = lines.includes(line);
+    if (on) {
+      git(root, ["config", `filter.${FILTER}.clean`, CLEAN]);
+      git(root, ["config", `filter.${FILTER}.required`, "false"]);
+      if (!has) {
+        fs3.mkdirSync(path3.dirname(file), { recursive: true });
+        fs3.writeFileSync(file, [...lines, line].join("\n") + "\n");
+      }
+      restage(root, abs);
+    } else if (has) {
+      const rest = lines.filter((l) => l !== line);
+      fs3.writeFileSync(file, rest.length ? rest.join("\n") + "\n" : "");
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isKept(root, abs) {
+  try {
+    return readLines(attributesFile(root)).includes(attrLine(rel(root, abs)));
+  } catch {
+    return false;
+  }
+}
+function restage(root, abs) {
+  if (isTracked(root, abs)) gitOk(root, ["add", "--", rel(root, abs)]);
+}
+var isAncestor = (root, commit) => !!commit && gitOk(root, ["merge-base", "--is-ancestor", commit, "HEAD"]);
+function changesBetween(root, from, to) {
+  try {
+    const out = git(root, ["-c", "core.quotePath=false", "log", "--reverse", "--first-parent", "--format=%x01", "--name-status", "-M", `${from}..${to}`]);
+    const renames = /* @__PURE__ */ new Map();
+    const added = /* @__PURE__ */ new Set();
+    for (const line of out.split(/\r?\n/)) {
+      const parts = line.split("	");
+      if (parts.length < 2) continue;
+      const status = parts[0][0];
+      if (status === "R") {
+        const [, oldP, newP] = parts;
+        const origin = [...renames.entries()].find(([, cur]) => cur === oldP)?.[0] ?? oldP;
+        if (added.delete(oldP)) added.add(newP);
+        else renames.set(origin, newP);
+      } else if (status === "A") added.add(parts[1]);
+      else if (status === "D") {
+        added.delete(parts[1]);
+        for (const [o, cur] of renames) if (cur === parts[1]) renames.delete(o);
+      }
+    }
+    const abs = (p) => path3.join(root, ...p.split("/"));
+    return [
+      ...[...renames].map(([o, n]) => ({ status: "R", from: abs(o), to: abs(n) })),
+      ...[...added].map((p) => ({ status: "A", from: abs(p), to: abs(p) }))
+    ];
+  } catch {
+    return [];
+  }
+}
+var HOOKS = ["post-merge", "post-checkout", "post-rewrite"];
+var begin = (home) => `# >>> tether (${home.replace(/\\/g, "/")}) >>>`;
+var end = (home) => `# <<< tether (${home.replace(/\\/g, "/")}) <<<`;
+function removeHooks(hooksDir, home) {
+  for (const hook of HOOKS) {
+    const file = path3.join(hooksDir, hook);
+    if (!fs3.existsSync(file)) continue;
+    let text = fs3.readFileSync(file, "utf8");
+    const b = text.indexOf(begin(home));
+    if (b < 0) continue;
+    const e = text.indexOf(end(home), b);
+    text = (text.slice(0, b) + (e < 0 ? "" : text.slice(e + end(home).length))).replace(/\n{3,}/g, "\n\n");
+    if (/^(#!.*\n)?\s*$/.test(text)) fs3.rmSync(file);
+    else fs3.writeFileSync(file, text.replace(/\s*$/, "\n"));
+  }
+}
+
+export {
+  isWindows,
+  tetherHome,
+  ipcEndpoint,
+  files,
+  IpcError,
+  listen,
+  call,
+  VERSION,
+  PACKAGE,
+  latestVersion,
+  isNewer,
+  installDir,
+  prefixOf,
+  npmInstall,
+  GIT_MODES,
+  gitBinary,
+  findRepo,
+  gitBusy,
+  head,
+  fileBlob,
+  blobAt,
+  indexBlob,
+  changeFromGit,
+  isTracked,
+  setKeep,
+  isKept,
+  restage,
+  isAncestor,
+  changesBetween,
+  removeHooks
+};