@longleash/cli 0.1.0-rc.4 → 0.1.0-rc.6

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
@@ -1616,6 +1692,27 @@ function processAlive(pid) {
   }
 }
 
+// src/setup-input.ts
+function resolveAllowedRootAnswer(answer, defaultRoot) {
+  const trimmed = answer.trim();
+  if (/^(?:y|yes|n|no)$/i.test(trimmed)) {
+    return {
+      ok: false,
+      message: `This question needs a folder path. Press Enter to use ${defaultRoot}, or type another existing folder.`
+    };
+  }
+  try {
+    const [root] = normalizeRoots([trimmed || defaultRoot]);
+    if (!root) throw new Error("At least one allowed project directory is required.");
+    return { ok: true, root };
+  } catch (error) {
+    return {
+      ok: false,
+      message: `That folder cannot be used: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+
 // src/service.ts
 import {
   chmodSync as chmodSync2,
@@ -2218,8 +2315,15 @@ async function setup(options) {
     try {
       console.log("\nLongLeash setup\n");
       console.log("Agents remain on this laptop. Choose only folders where they may work.");
-      const rootAnswer = await prompt.question(`Allowed project folder [${process.cwd()}]: `);
-      options.roots = [rootAnswer.trim() || process.cwd()];
+      const defaultRoot = process.cwd();
+      while (options.roots.length === 0) {
+        const rootAnswer = await prompt.question(`Allowed project folder (press Enter for ${defaultRoot}): `);
+        const resolved = resolveAllowedRootAnswer(rootAnswer, defaultRoot);
+        if (resolved.ok) options.roots = [resolved.root];
+        else console.log(`
+${resolved.message}
+`);
+      }
       console.log("\nConnectivity: hosted works away from home; LAN-only has no internet relay.");
       const relayAnswer = await prompt.question("Relay [hosted / lan / wss://your-relay/ws] (hosted): ");
       options.relay = relayAnswer.trim() || "hosted";
@@ -2264,7 +2368,10 @@ async function setup(options) {
       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);
@@ -2492,6 +2599,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.4",
+  "version": "0.1.0-rc.6",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@longleash/cli",
-      "version": "0.1.0-rc.4",
+      "version": "0.1.0-rc.6",
       "license": "MIT",
       "os": [
         "darwin",

package/package.json

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