@longleash/cli 0.1.0-rc.5 → 0.1.0-rc.7

package/bin/longleash.mjs

@@ -1401,27 +1401,42 @@ function prepareManagedInstall(version, env = process.env) {
         const hadWrapper = pathExists2(paths.wrapper);
         const hadMarker = pathExists2(marker);
         let previousWrapper;
+        let previousWrapperMode = 448;
         let previousMarker;
         let wrapperWritten = false;
         let markerWritten = false;
+        let migratedLegacyWrapper = false;
+        let legacyWrapper;
         const tempLink = join2(paths.home, `.current-${process.pid}-${randomUUID2()}`);
         try {
           mkdirSync2(paths.bin, { recursive: true, mode: 448 });
           if (hadWrapper) {
-            if (lstatSync2(paths.wrapper).isSymbolicLink()) throw new Error(`Refusing symlinked executable: ${paths.wrapper}`);
+            const wrapperStat = lstatSync2(paths.wrapper);
+            if (wrapperStat.isSymbolicLink()) throw new Error(`Refusing symlinked executable: ${paths.wrapper}`);
+            if (!wrapperStat.isFile()) throw new Error(`Refusing non-file executable: ${paths.wrapper}`);
+            if (process.getuid !== void 0 && wrapperStat.uid !== process.getuid()) {
+              throw new Error(`Refusing executable owned by another user: ${paths.wrapper}`);
+            }
             previousWrapper = readFileSync2(paths.wrapper, "utf8");
+            previousWrapperMode = wrapperStat.mode & 511;
             if (!previousWrapper.includes(WRAPPER_MARKER)) {
-              throw new Error(`Refusing to replace an unmanaged executable: ${paths.wrapper}`);
+              legacyWrapper = recognizeLegacyWrapper(previousWrapper, wrapperStat.mode & 511, paths.wrapper);
+              migratedLegacyWrapper = true;
             }
           }
           if (hadMarker) {
             if (lstatSync2(marker).isSymbolicLink()) throw new Error(`Refusing symlinked install marker: ${marker}`);
             previousMarker = readFileSync2(marker, "utf8");
+            const parsed = parseInstallMarker(previousMarker, marker);
+            if (parsed.package !== PACKAGE_NAME) throw new Error(`Refusing unrecognized install marker: ${marker}`);
+            legacyWrapper = parsed.legacyWrapper ?? legacyWrapper;
           }
           const activeCli = join2(paths.current, "node_modules", "@longleash", "cli", "bin", "longleash.mjs");
           writeExecutableAtomically(paths.wrapper, wrapper(activeCli, process.execPath));
           wrapperWritten = true;
-          writeFileAtomically(marker, `${JSON.stringify({ schema: 1, package: PACKAGE_NAME }, null, 2)}
+          const nextMarker = { schema: 1, package: PACKAGE_NAME };
+          if (legacyWrapper) nextMarker.legacyWrapper = legacyWrapper;
+          writeFileAtomically(marker, `${JSON.stringify(nextMarker, null, 2)}
 `, 384);
           markerWritten = true;
           symlinkSync(release, tempLink, "dir");
@@ -1430,6 +1445,7 @@ function prepareManagedInstall(version, env = process.env) {
           }
           renameSync2(tempLink, paths.current);
           activated = true;
+          return { migratedLegacyWrapper };
         } catch (error) {
           try {
             rmSync2(tempLink, { force: true });
@@ -1438,7 +1454,7 @@ function prepareManagedInstall(version, env = process.env) {
           const restorationFailures = [];
           if (wrapperWritten) {
             try {
-              restoreManagedFile(paths.wrapper, hadWrapper ? previousWrapper : void 0, 448);
+              restoreManagedFile(paths.wrapper, hadWrapper ? previousWrapper : void 0, previousWrapperMode);
             } catch (restoreError) {
               restorationFailures.push(`executable: ${String(restoreError)}`);
             }
@@ -1478,18 +1494,78 @@ function prepareManagedInstall(version, env = process.env) {
 function uninstallManagedRuntime(env = process.env) {
   const paths = installPaths(env);
   const marker = join2(paths.home, MARKER);
-  if (!pathExists2(marker)) return { removed: false, configPreserved: resolve2(env.LONGLEASH_DATA ?? join2(homedir2(), ".longleash")) };
+  if (!pathExists2(marker)) {
+    return {
+      removed: false,
+      configPreserved: resolve2(env.LONGLEASH_DATA ?? join2(homedir2(), ".longleash")),
+      legacyWrapperRestored: false
+    };
+  }
   if (lstatSync2(marker).isSymbolicLink()) throw new Error(`Refusing symlinked install marker: ${marker}`);
-  const parsed = JSON.parse(readFileSync2(marker, "utf8"));
+  const parsed = parseInstallMarker(readFileSync2(marker, "utf8"), marker);
   if (parsed.package !== PACKAGE_NAME) throw new Error(`Refusing to remove unrecognized install directory: ${paths.home}`);
+  let legacyWrapperRestored = false;
   if (pathExists2(paths.wrapper)) {
     if (lstatSync2(paths.wrapper).isSymbolicLink()) throw new Error(`Refusing symlinked executable: ${paths.wrapper}`);
     const wrapperText = readFileSync2(paths.wrapper, "utf8");
     if (!wrapperText.includes(WRAPPER_MARKER)) throw new Error(`Refusing to remove an unmanaged executable: ${paths.wrapper}`);
-    rmSync2(paths.wrapper);
+    if (parsed.legacyWrapper) {
+      const backup = validateLegacyBackup(parsed.legacyWrapper, paths.wrapper);
+      writeFileAtomically(paths.wrapper, backup.content, backup.mode);
+      legacyWrapperRestored = true;
+    } else {
+      rmSync2(paths.wrapper);
+    }
   }
   rmSync2(paths.home, { recursive: true });
-  return { removed: true, configPreserved: resolve2(env.LONGLEASH_DATA ?? join2(homedir2(), ".longleash")) };
+  return {
+    removed: true,
+    configPreserved: resolve2(env.LONGLEASH_DATA ?? join2(homedir2(), ".longleash")),
+    legacyWrapperRestored
+  };
+}
+function recognizeLegacyWrapper(content, mode, wrapperPath) {
+  if (Buffer.byteLength(content, "utf8") > 16 * 1024) {
+    throw new Error(`Refusing to replace an unmanaged executable: ${wrapperPath}`);
+  }
+  const match = content.match(
+    /^#!\/usr\/bin\/env bash\n# Created by the LongLeash installer\. The three values below are the settings; the behaviour\n# lives in \$LONGLEASH_DIR\/scripts\/longleash\.sh and updates with the code\.\nset -euo pipefail\nexport LONGLEASH_DIR="([^"\n]+)"\nexport LONGLEASH_DEFAULT_ROOTS="([^"\n]*)"\nexport LONGLEASH_DEFAULT_RELAY="([^"\n]*)"\nexec bash "\$LONGLEASH_DIR\/scripts\/longleash\.sh" "\$@"\n?$/
+  );
+  if (!match) throw new Error(`Refusing to replace an unmanaged executable: ${wrapperPath}`);
+  const legacyRoot = match[1];
+  if (!legacyRoot || resolve2(legacyRoot) !== legacyRoot) {
+    throw new Error(`Refusing legacy executable with an unsafe checkout path: ${wrapperPath}`);
+  }
+  const legacyEntrypoint = join2(legacyRoot, "scripts", "longleash.sh");
+  if (!pathExists2(legacyEntrypoint) || lstatSync2(legacyEntrypoint).isSymbolicLink() || !lstatSync2(legacyEntrypoint).isFile()) {
+    throw new Error(`The verified legacy executable points to a missing checkout: ${legacyRoot}`);
+  }
+  return { content, mode: normalizeExecutableMode(mode) };
+}
+function validateLegacyBackup(value, wrapperPath) {
+  if (!value || typeof value.content !== "string" || !Number.isSafeInteger(value.mode)) {
+    throw new Error(`Refusing invalid legacy executable backup in the install marker: ${wrapperPath}`);
+  }
+  return recognizeLegacyWrapper(value.content, value.mode, wrapperPath);
+}
+function parseInstallMarker(content, markerPath) {
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch {
+    throw new Error(`Refusing invalid install marker: ${markerPath}`);
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`Refusing invalid install marker: ${markerPath}`);
+  }
+  const marker = parsed;
+  if (marker.legacyWrapper !== void 0) validateLegacyBackup(marker.legacyWrapper, markerPath);
+  return marker;
+}
+function normalizeExecutableMode(mode) {
+  const normalized = mode & 511;
+  if ((normalized & 64) === 0) throw new Error("The legacy LongLeash executable is not owner-executable.");
+  return normalized;
 }
 function wrapper(cli, node) {
   return `#!/bin/sh
@@ -1740,8 +1816,8 @@ StartLimitBurst=5
 [Service]
 Type=simple
 ExecStart=${systemdQuote(paths.wrapper)} run
-EnvironmentFile=${systemdQuote(paths.environment)}
-WorkingDirectory=${systemdQuote(home)}
+EnvironmentFile=${systemdPath(paths.environment)}
+WorkingDirectory=${systemdPath(home)}
 UMask=0077
 Restart=on-failure
 RestartSec=5s
@@ -1895,16 +1971,28 @@ function installSystemdService(context) {
   if (!context.paths.environment) throw new Error("The Linux service environment path is missing.");
   const previousUnit = snapshot(context.paths.definition);
   const previousEnvironment = snapshot(context.paths.environment);
+  const wasEnabled = run(context, "systemctl", ["--user", "is-enabled", "--quiet", SYSTEMD_UNIT]).status === 0;
+  const wasActive = run(context, "systemctl", ["--user", "is-active", "--quiet", SYSTEMD_UNIT]).status === 0;
   try {
     writeManagedAtomically(context.paths.environment, renderSystemdEnvironment(context.paths, context.env), 384);
     writeManagedAtomically(context.paths.definition, renderSystemdUnit(context.paths, context.home), 384);
     requireSuccess(context, "systemctl", ["--user", "daemon-reload"]);
-    requireSuccess(context, "systemctl", ["--user", "enable", "--now", SYSTEMD_UNIT]);
+    if (wasActive) {
+      if (!wasEnabled) requireSuccess(context, "systemctl", ["--user", "enable", SYSTEMD_UNIT]);
+      requireSuccess(context, "systemctl", ["--user", "restart", SYSTEMD_UNIT]);
+    } else {
+      requireSuccess(context, "systemctl", ["--user", "enable", "--now", SYSTEMD_UNIT]);
+    }
   } catch (error) {
     restore(context.paths.environment, previousEnvironment);
     restore(context.paths.definition, previousUnit);
     run(context, "systemctl", ["--user", "daemon-reload"]);
-    if (previousUnit !== null) run(context, "systemctl", ["--user", "enable", "--now", SYSTEMD_UNIT]);
+    if (previousUnit !== null) {
+      if (wasEnabled) run(context, "systemctl", ["--user", "enable", SYSTEMD_UNIT]);
+      else run(context, "systemctl", ["--user", "disable", SYSTEMD_UNIT]);
+      if (wasActive) run(context, "systemctl", ["--user", "restart", SYSTEMD_UNIT]);
+      else run(context, "systemctl", ["--user", "stop", SYSTEMD_UNIT]);
+    }
     throw error;
   }
 }
@@ -2026,6 +2114,12 @@ function systemdQuote(value) {
   if (/[\0\r\n]/.test(value)) throw new Error("Service paths may not contain control characters.");
   return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/%/g, "%%")}"`;
 }
+function systemdPath(value) {
+  if (/[\u0000-\u0008\u000a-\u001f\u007f-\u009f]/.test(value)) {
+    throw new Error("Service paths may not contain control characters.");
+  }
+  return value.replace(/%/g, "%%").replace(/\\/g, "\\x5c").replace(/ /g, "\\x20").replace(/\t/g, "\\x09").replace(/"/g, "\\x22").replace(/'/g, "\\x27");
+}
 function environmentQuote(value) {
   if (/[\0\r\n]/.test(value)) throw new Error("Service environment values may not contain control characters.");
   return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
@@ -2292,7 +2386,10 @@ ${resolved.message}
       throw new Error("The staged package could not be configured. The active version was not changed.");
     }
     try {
-      prepared.activate();
+      const activation = prepared.activate();
+      if (activation.migratedLegacyWrapper) {
+        console.log("Migrated the verified legacy LongLeash command. Its checkout was preserved and will be restored if you uninstall this runtime.");
+      }
     } catch (error) {
       prepared.rollback();
       restoreConfigSnapshot(configSnapshot);
@@ -2520,6 +2617,7 @@ async function uninstall() {
   if (hooksRemoved !== 0) throw new Error("Provider hooks could not be removed safely. The managed runtime was preserved.");
   const result = uninstallManagedRuntime();
   console.log(result.removed ? "Removed the managed LongLeash runtime and executable." : "No managed LongLeash runtime was installed.");
+  if (result.legacyWrapperRestored) console.log("Restored the verified legacy LongLeash command that existed before the npm migration.");
   console.log(`Preserved settings, paired devices, and audit data in ${result.configPreserved}.`);
   return 0;
 }

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@longleash/cli",
-  "version": "0.1.0-rc.5",
+  "version": "0.1.0-rc.7",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@longleash/cli",
-      "version": "0.1.0-rc.5",
+      "version": "0.1.0-rc.7",
       "license": "MIT",
       "os": [
         "darwin",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@longleash/cli",
-  "version": "0.1.0-rc.5",
+  "version": "0.1.0-rc.7",
   "description": "Securely control Claude Code and Codex sessions on your laptop from your phone.",
   "license": "MIT",
   "type": "module",