tether-sync 0.1.0 → 0.4.0

package/bin/tether.js

@@ -1,11 +1,19 @@
 #!/usr/bin/env node
 import {
   IpcError,
+  PACKAGE,
+  VERSION,
   call,
+  findRepo,
+  installDir,
   ipcEndpoint,
+  isNewer,
   isWindows,
+  latestVersion,
+  npmInstall,
+  prefixOf,
   tetherHome
-} from "./chunk-MGMU33LE.js";
+} from "./chunk-NMLHD2KU.js";
 
 // packages/client/src/cli.js
 import path2 from "node:path";
@@ -164,13 +172,35 @@ async function resolveFlow(p, from, opts) {
   }
   const { results } = await daemon("resolve", { path: target, from, items: plan.items, choices });
   for (const r of results) {
-    const extra = r.error ? `  ERROR: ${r.error}` : r.version ? `  -> v${r.version}` : r.keptAs ? `  (your copy: ${r.keptAs})` : r.released ? `  (left at ${r.released})` : "";
+    const extra = r.error ? `  ERROR: ${r.error}` : r.version ? `  -> v${r.version}${r.sent ? ` (${r.sent})` : ""}` : r.keptAs ? `  (your copy: ${r.keptAs})` : r.released ? `  (left at ${r.released})` : "";
     out(`${r.action.padEnd(9)} ${r.path}${extra}`);
   }
   if (results.some((r) => r.error)) process.exitCode = 1;
 }
+async function chooseGitMode(target, flag, canFollow) {
+  const repo = findRepo(target);
+  if (!repo) return void 0;
+  if (flag) {
+    if (flag === "follow" && !canFollow) throw new Error("--git follow needs editor access (you are a viewer); use --git keep or --git skip");
+    return flag;
+  }
+  if (!process.stdin.isTTY) {
+    out(`note: ${target} is inside the git repository ${repo.root}; Tether will revert git's changes to it. Choose with --git keep|follow|skip.`);
+    return "keep";
+  }
+  out(`${target} is inside the git repository ${repo.root}.`);
+  out("How should Tether treat it when git changes it?");
+  out("  [1] keep managing it: git's changes (pull, checkout, switch, merge) may get reverted to Tether's version");
+  out("      (git is told to ignore Tether's copy, so git status stays clean and pulls are not blocked)");
+  out("  [2] do not let Tether manage it");
+  if (canFollow) out("  [3] manage it, and after a git pull, checkout, switch or merge accept git's version and publish it to Tether");
+  else out("  (option 3, accepting git's changes, needs editor access)");
+  const choice = await ask("  > ", canFollow ? ["1", "2", "3"] : ["1", "2"]);
+  return { 1: "keep", 2: "skip", 3: "follow" }[choice];
+}
 function printStatus(s, verbose) {
   out(`server: ${s.server}  user: ${s.user ? s.user.email : "(not signed in)"}${s.offline ? `  OFFLINE: ${s.offline}` : ""}`);
+  if (isNewer(s.latest, s.version)) out(`update available: ${s.version} -> ${s.latest} (run \`tether update\`)`);
   if (!s.instances.length) return out("nothing managed yet");
   const folders = new Map(s.instances.filter((i) => i.kind === "folder").map((i) => [i.instanceId, i]));
   for (const i of s.instances) {
@@ -197,7 +227,7 @@ async function main(argv) {
     if (e.code === "EPIPE") process.exit(0);
     throw e;
   });
-  const program = new Command("tether").description("Keep files in sync with a central source of truth, wherever they live.").version("0.1.0");
+  const program = new Command("tether").description("Keep files in sync with a central source of truth, wherever they live.").version(VERSION);
   program.showHelpAfterError();
   program.command("login").description("sign in (opens the browser)").option("--email <email>", "sign in with email and password instead (local development)").option("--password <password>").option("--signup", "create the account (with --email)").action(async (o) => {
     if (o.email) {
@@ -252,8 +282,10 @@ async function main(argv) {
     const r = await daemon("repo.eol", { ref, glob, mode });
     out(`eol rules: ${JSON.stringify(r.eolDefaults)}`);
   });
-  program.command("manage <path>").description("upload a file or folder into a repo; you become its owner").requiredOption("--repo <repo>").addOption(new Option("--eol <mode>").choices(["auto", "lf", "crlf", "binary"])).action(async (p, o) => {
-    const r = await daemon("manage", { path: path2.resolve(p), repo: o.repo, eol: o.eol });
+  program.command("manage <path>").description("upload a file or folder into a repo; you become its owner").requiredOption("--repo <repo>").addOption(new Option("--eol <mode>").choices(["auto", "lf", "crlf", "binary"])).addOption(new Option("--git <mode>", "inside a git repo: keep (Tether reverts git changes), follow (publish git changes), skip").choices(["keep", "follow", "skip"])).action(async (p, o) => {
+    const gitMode = await chooseGitMode(path2.resolve(p), o.git, true);
+    if (gitMode === "skip") return out("not managed");
+    const r = await daemon("manage", { path: path2.resolve(p), repo: o.repo, eol: o.eol, gitMode });
     out(`managing ${r.path} (${r.kind}${r.kind === "folder" ? `, ${r.files} files` : ""})`);
     if (r.skippedSymlinks?.length) out(`skipped symlinks: ${r.skippedSymlinks.join(", ")}`);
     out(`share ID: ${r.shareId}`);
@@ -262,18 +294,31 @@ async function main(argv) {
     const r = await daemon("add", { path: path2.resolve(p) });
     out(`added ${r.relPath} to ${r.folder}`);
   });
-  program.command("pull <shareId> [dest]").description("get a managed copy").action(async (shareId, dest) => {
-    const r = await daemon("pull", { shareId, dest, cwd: process.cwd() });
+  program.command("pull <shareId> [dest]").description("get a managed copy").addOption(new Option("--git <mode>", "inside a git repo: keep (Tether reverts git changes), follow (publish git changes; editors), skip").choices(["keep", "follow", "skip"])).action(async (shareId, dest, o) => {
+    const peek = await daemon("pull", { shareId, dest, cwd: process.cwd(), peek: true });
+    const gitMode = await chooseGitMode(peek.path, o.git, peek.role !== "viewer");
+    if (gitMode === "skip") return out("not pulled");
+    const r = await daemon("pull", { shareId, dest, cwd: process.cwd(), gitMode });
     out(`pulled ${r.path} (${r.kind}${r.kind === "folder" ? `, ${r.files} files` : ""}, v${r.version}) as ${r.role}`);
+    if (r.note) out(`note: ${r.note}`);
   });
   program.command("status [path]").description("modes, pending changes, problems").option("-v, --verbose", "show every file and instance IDs").option("--json").action(async (p, o) => {
     const s = await daemon("status", { path: p ? path2.resolve(p) : void 0 });
     if (o.json) return json(s);
     printStatus(s, o.verbose);
   });
-  program.command("edit <path>").description("start editing: local changes are kept until `tether done`").action(async (p) => {
-    const r = await daemon("edit", { path: path2.resolve(p) });
+  program.command("edit <path>").description("start editing: local changes are kept until `tether done`").option("--realtime", "push every save immediately (editors only, one realtime editor per file)").action(async (p, o) => {
+    const r = await daemon("edit", { path: path2.resolve(p), realtime: !!o.realtime });
+    if (r.realtime) {
+      out(`editing ${r.changed.length} file(s) in realtime: every save is pushed to everyone within seconds.`);
+      out(`Other editors cannot start realtime on them until you run \`tether done ${p}\`.`);
+      return;
+    }
     out(r.changed.length ? `editing ${r.changed.length} file(s); run \`tether done ${p}\` to finish` : "nothing to change (already editing?)");
+    for (const w of r.warnings ?? []) {
+      out(`warning: ${w.path} is being edited in realtime by ${w.email} (since ${new Date(w.since).toLocaleTimeString()}).`);
+      out("         Their changes keep arriving on the server; expect merge conflicts when you run `tether done`.");
+    }
   });
   program.command("done [path]").description("finish editing: push changes and resolve conflicts").addOption(new Option("--resolve <choice>", "answer every question with this choice").choices(["push", "accept", "keep-both", "cancel", "delete", "stop"])).action((p, o) => resolveFlow(p, "editing", o));
   program.command("unmanage <path>").description("stop syncing (location is still followed)").action(async (p) => {
@@ -359,6 +404,40 @@ async function main(argv) {
     uninstall();
     out("removed from login startup");
   });
+  program.command("update").description(`update tether to the latest version on npm (${PACKAGE})`).option("--check", "only check whether an update is available").action(async (o) => {
+    const latest = await latestVersion();
+    if (!latest) throw new Error("could not reach the npm registry");
+    if (!isNewer(latest, VERSION)) return out(`tether ${VERSION} is up to date`);
+    if (o.check) return out(`update available: ${VERSION} -> ${latest} (run \`tether update\`)`);
+    const pkgDir = installDir();
+    if (!pkgDir) throw new Error("this tether is a development copy (not installed from npm); update it with `git pull` and `npm install`");
+    out(`updating tether ${VERSION} -> ${latest}`);
+    let wasRunning = false;
+    try {
+      await call(endpoint(), "shutdown", {}, 3e3);
+      wasRunning = true;
+      for (let i = 0; i < 50; i++) {
+        await new Promise((r) => setTimeout(r, 100));
+        await call(endpoint(), "ping", {}, 500);
+      }
+    } catch {
+    }
+    const code = npmInstall(process.env.TETHER_UPDATE_SPEC || `${PACKAGE}@${latest}`, prefixOf(pkgDir));
+    if (code !== 0) {
+      if (wasRunning) spawnDaemon();
+      throw new Error("npm install failed; tether was not updated. If another Tether daemon from this install is running (another TETHER_HOME), stop it and try again.");
+    }
+    if (wasRunning) spawnDaemon();
+    out(`updated to ${latest}`);
+  });
+  program.command("git <path>").description("show or change how a managed file shares its git repository").addOption(new Option("--mode <mode>", "keep: Tether reverts git's changes; follow: git's changes are published (editors)").choices(["keep", "follow"])).action(async (p, o) => {
+    for (const i of await daemon("git.mode", { path: path2.resolve(p), mode: o.mode })) {
+      out(`${(i.gitMode ?? (i.gitRoot ? "keep" : "-")).padEnd(7)} ${(i.role ?? "").padEnd(6)} ${i.path}${i.gitRoot ? "" : "  (not in a git repo)"}`);
+    }
+  });
+  program.command("git-sync", { hidden: true }).description("used by git hooks").requiredOption("--repo <dir>").option("--hook <name>").action(async (o) => {
+    await daemon("git.sync", { repo: path2.resolve(o.repo), hook: o.hook });
+  });
   program.command("sync").description("run a sync pass now").action(async () => {
     const r = await daemon("sync");
     out(r.offline ? `offline: ${r.offline}` : "synced");

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-WGNVBSEJ.js");
+var { runDaemon } = await import("./daemon-5IFWP5O3.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.1.0",
+  "version": "0.4.0",
   "description": "Keep files identical to a central source of truth, wherever they live on your machine.",
   "type": "module",
   "bin": {

package/bin/chunk-MGMU33LE.js

@@ -1,109 +0,0 @@
-// 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"));
-      }
-    });
-  });
-}
-
-export {
-  isWindows,
-  tetherHome,
-  ipcEndpoint,
-  files,
-  IpcError,
-  listen,
-  call
-};